bolt 3.7.1 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 741f798df2b4c7a46e45c5c87a41cd4e994506cdd202d26b6acafae7774135f8
-  data.tar.gz: 803789a5f6872e27656a733e94998acc9dde4d325d2d920b345a1c2848683f2f
+  metadata.gz: 1f4c856f3322c88dabb51efe39bc7373d96e33f6274785188900e8fbb5488436
+  data.tar.gz: 5e5da3f150093febfc2b6d7e343e9995ea33b044fb4941ed9229944e4735aa72
 SHA512:
-  metadata.gz: 85cb83b0a0bf02d1ba15b14ba5e5e75c6ff290e1acee71b0de06ea716f3698e91358aa6f9961757b088afa3c98d519ba10f79a6195c767492a87603759c2fc81
-  data.tar.gz: 8180f0827c3576e676e6fca59af7744d3e375023b44c0ebc2e691801a25f8fc1cac2487276661f7b40503e8ab1164ae07ee5f8343be9bb5be3088851e81eafaf
+  metadata.gz: 8f88f29b98a7bab28a4bbae5e860bb4c94fca20dd994241b71f2e5327934a92db1370c77fdb03d5f9a033e626b726e379e3eec510f0316b67b0807aa86920b67
+  data.tar.gz: 8cf9a3bbfde78b7930089a7ada109e03bba5439ea8ef3049d3fa58bc589914881969be783fe667ef5c238613e126c7f79d7dd0db30fcd2f5d9147999086d1df7

data/Puppetfile

@@ -6,7 +6,7 @@ moduledir File.join(File.dirname(__FILE__), 'modules')
 
 # Core modules used by 'apply'
 mod 'puppetlabs-service', '2.0.0'
-mod 'puppetlabs-puppet_agent', '4.5.0'
+mod 'puppetlabs-puppet_agent', '4.6.1'
 mod 'puppetlabs-facts', '1.4.0'
 
 # Core types and providers for Puppet 6
@@ -17,7 +17,7 @@ mod 'puppetlabs-sshkeys_core', '2.2.0'
 mod 'puppetlabs-zfs_core', '1.2.0'
 mod 'puppetlabs-cron_core', '1.0.5'
 mod 'puppetlabs-mount_core', '1.0.4'
-mod 'puppetlabs-selinux_core', '1.0.4'
+mod 'puppetlabs-selinux_core', '1.1.0'
 mod 'puppetlabs-yumrepo_core', '1.0.7'
 mod 'puppetlabs-zone_core', '1.0.3'
 
@@ -29,7 +29,7 @@ mod 'puppetlabs-python_task_helper', '0.5.0'
 mod 'puppetlabs-reboot', '4.0.2'
 mod 'puppetlabs-ruby_task_helper', '0.6.0'
 mod 'puppetlabs-ruby_plugin_helper', '0.2.0'
-mod 'puppetlabs-stdlib', '7.0.0'
+mod 'puppetlabs-stdlib', '7.0.1'
 
 # Plugin modules
 mod 'puppetlabs-aws_inventory', '0.7.0'

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

@@ -108,7 +108,11 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     # Send Analytics Report
     executor.report_function_call(self.class.name)
 
-    found = Puppet::Parser::Files.find_file(script, scope.compiler.environment)
+    future = executor&.future || {}
+    fallback = future.fetch('file_paths', false)
+
+    # Find the file path if it exists, otherwise return nil
+    found = Bolt::Util.find_file_from_scope(script, scope, fallback)
     unless found && Puppet::FileSystem.exist?(found)
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, file: script

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

@@ -70,7 +70,11 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
     # Send Analytics Report
     executor.report_function_call(self.class.name)
 
-    found = Puppet::Parser::Files.find_file(source, scope.compiler.environment)
+    future = executor&.future || {}
+    fallback = future.fetch('file_paths', false)
+
+    # Find the file path if it exists, otherwise return nil
+    found = Bolt::Util.find_file_from_scope(source, scope, fallback)
     unless found && Puppet::FileSystem.exist?(found)
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, file: source

data/bolt-modules/file/lib/puppet/functions/file/exists.rb

@@ -12,14 +12,20 @@ Puppet::Functions.create_function(:'file::exists', Puppet::Functions::InternalFu
   #   file::exists('example/VERSION')
   dispatch :exists do
     scope_param
-    required_param 'String', :filename
+    required_param 'String[1]', :filename
     return_type 'Boolean'
   end
 
   def exists(scope, filename)
     # Send Analytics Report
-    Puppet.lookup(:bolt_executor) {}&.report_function_call(self.class.name)
-    found = Puppet::Parser::Files.find_file(filename, scope.compiler.environment)
+    executor = Puppet.lookup(:bolt_executor) {}
+    executor&.report_function_call(self.class.name)
+
+    future = executor&.future || Puppet.lookup(:future) || {}
+    fallback = future.fetch('file_paths', false)
+
+    # Find the file path if it exists, otherwise return nil
+    found = Bolt::Util.find_file_from_scope(filename, scope, fallback)
     found ? Puppet::FileSystem.exist?(found) : false
   end
 end

data/bolt-modules/file/lib/puppet/functions/file/read.rb

@@ -11,7 +11,7 @@ Puppet::Functions.create_function(:'file::read', Puppet::Functions::InternalFunc
   #   file::read('example/VERSION')
   dispatch :read do
     scope_param
-    required_param 'String', :filename
+    required_param 'String[1]', :filename
     return_type 'String'
   end
 
@@ -20,7 +20,11 @@ Puppet::Functions.create_function(:'file::read', Puppet::Functions::InternalFunc
     executor = Puppet.lookup(:bolt_executor) {}
     executor&.report_function_call(self.class.name)
 
-    found = Puppet::Parser::Files.find_file(filename, scope.compiler.environment)
+    future = executor&.future || Puppet.lookup(:future) || {}
+    fallback = future.fetch('file_paths', false)
+
+    # Find the file path if it exists, otherwise return nil
+    found = Bolt::Util.find_file_from_scope(filename, scope, fallback)
     unless found && Puppet::FileSystem.exist?(found)
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, file: filename

data/bolt-modules/file/lib/puppet/functions/file/readable.rb

@@ -12,15 +12,20 @@ Puppet::Functions.create_function(:'file::readable', Puppet::Functions::Internal
   #   file::readable('example/VERSION')
   dispatch :readable do
     scope_param
-    required_param 'String', :filename
+    required_param 'String[1]', :filename
     return_type 'Boolean'
   end
 
   def readable(scope, filename)
     # Send Analytics Report
-    Puppet.lookup(:bolt_executor) {}&.report_function_call(self.class.name)
+    executor = Puppet.lookup(:bolt_executor) {}
+    executor&.report_function_call(self.class.name)
 
-    found = Puppet::Parser::Files.find_file(filename, scope.compiler.environment)
+    future = executor&.future || Puppet.lookup(:future) || {}
+    fallback = future.fetch('file_paths', false)
+
+    # Find the file path if it exists, otherwise return nil
+    found = Bolt::Util.find_file_from_scope(filename, scope, fallback)
     found ? File.readable?(found) : false
   end
 end

data/lib/bolt/applicator.rb

@@ -87,7 +87,7 @@ module Bolt
         variables: @inventory.vars(target),
         trusted: trusted.to_h
       }
-      catalog_request = scope.merge(target: target_data)
+      catalog_request = scope.merge(target: target_data).merge(future: @executor.future || {})
 
       bolt_catalog_exe = File.join(libexec, 'bolt_catalog')
       old_path = ENV['PATH']

data/lib/bolt/bolt_option_parser.rb

@@ -66,6 +66,9 @@ module Bolt
       when 'guide'
         { flags: OPTIONS[:global] + %w[format],
           banner: GUIDE_HELP }
+      when 'lookup'
+        { flags: ACTION_OPTS + %w[hiera-config],
+          banner: LOOKUP_HELP }
       when 'module'
         case action
         when 'add'
@@ -187,6 +190,7 @@ module Bolt
           guide             View guides for Bolt concepts and features
           inventory         Show the list of targets an action would run on
           module            Manage Bolt project modules
+          lookup            Look up a value with Hiera
           plan              Convert, create, show, and run Bolt plans
           project           Create and migrate Bolt projects
           script            Upload a local script and run it remotely
@@ -398,6 +402,24 @@ module Bolt
           To learn more about the inventory run 'bolt guide inventory'.
     HELP
 
+    LOOKUP_HELP = <<~HELP
+      #{colorize(:cyan, 'Name')}
+          lookup
+
+      #{colorize(:cyan, 'Usage')}
+          bolt lookup <key> {--targets TARGETS | --query QUERY | --rerun FILTER}
+            [options]
+
+      #{colorize(:cyan, 'Description')}
+          Look up a value with Hiera.
+
+      #{colorize(:cyan, 'Documentation')}
+          Learn more about using Hiera with Bolt at https://pup.pt/bolt-hiera.
+
+      #{colorize(:cyan, 'Examples')}
+          bolt lookup password --targets servers
+    HELP
+
     MODULE_HELP = <<~HELP
       #{colorize(:cyan, 'Name')}
           module

data/lib/bolt/catalog.rb

@@ -65,7 +65,8 @@ module Bolt
       puppet_overrides = {
         bolt_pdb_client: pdb_client,
         bolt_inventory: inv,
-        bolt_project: bolt_project
+        bolt_project: bolt_project,
+        future: request['future']
       }
 
       # Facts will be set by the catalog compiler, so we need to ensure

data/lib/bolt/cli.rb

@@ -33,18 +33,19 @@ module Bolt
 
   class CLI
     COMMANDS = {
-      'command' => %w[run],
-      'script' => %w[run],
-      'task' => %w[show run],
-      'plan' => %w[show run convert new],
-      'file' => %w[download upload],
-      'secret' => %w[encrypt decrypt createkeys],
+      'apply'     => %w[],
+      'command'   => %w[run],
+      'file'      => %w[download upload],
+      'group'     => %w[show],
+      'guide'     => %w[],
       'inventory' => %w[show],
-      'group' => %w[show],
-      'project' => %w[init migrate],
-      'module' => %w[add generate-types install show],
-      'apply' => %w[],
-      'guide' => %w[]
+      'lookup'    => %w[],
+      'module'    => %w[add generate-types install show],
+      'plan'      => %w[show run convert new],
+      'project'   => %w[init migrate],
+      'script'    => %w[run],
+      'secret'    => %w[encrypt decrypt createkeys],
+      'task'      => %w[show run]
     }.freeze
 
     TARGETING_OPTIONS = %i[query rerun targets].freeze
@@ -326,6 +327,10 @@ module Bolt
         raise Bolt::CLIError, "a manifest file or --execute is required"
       end
 
+      if options[:subcommand] == 'lookup' && !options[:object]
+        raise Bolt::CLIError, "Must specify a key to look up"
+      end
+
       if options[:subcommand] == 'command' && (!options[:object] || options[:object].empty?)
         raise Bolt::CLIError, "Must specify a command to run"
       end
@@ -511,6 +516,8 @@ module Bolt
         when 'migrate'
           code = Bolt::ProjectManager.new(config, outputter, pal).migrate
         end
+      when 'lookup'
+        code = lookup(options[:object], options[:targets])
       when 'plan'
         case options[:action]
         when 'new'
@@ -563,7 +570,8 @@ module Bolt
             when 'command'
               executor.run_command(targets, options[:object], executor_opts)
             when 'script'
-              script_path = find_file(options[:object])
+              script_path = find_file(options[:object], executor.future&.fetch('file_paths', false))
+              validate_file('script', script_path)
               executor.run_script(targets, script_path, options[:leftovers], executor_opts)
             when 'task'
               pal.run_task(options[:object],
@@ -588,8 +596,9 @@ module Bolt
                 dest = File.expand_path(dest, Dir.pwd)
                 executor.download_file(targets, src, dest, executor_opts)
               when 'upload'
-                validate_file('source file', src, true)
-                executor.upload_file(targets, src, dest, executor_opts)
+                src_path = find_file(src, executor.future&.fetch('file_paths', false))
+                validate_file('source file', src_path, true)
+                executor.upload_file(targets, src_path, dest, executor_opts)
               end
             end
         end
@@ -686,6 +695,38 @@ module Bolt
       outputter.print_groups(inventory.group_names.sort, inventory.source, config.default_inventoryfile)
     end
 
+    # Looks up a value with Hiera, using targets as the contexts to perform the
+    # look ups in.
+    #
+    def lookup(key, targets)
+      executor = Bolt::Executor.new(
+        config.concurrency,
+        analytics,
+        options[:noop],
+        config.modified_concurrency,
+        config.future
+      )
+
+      executor.subscribe(outputter) if options.fetch(:format, 'human') == 'human'
+      executor.subscribe(log_outputter)
+      executor.publish_event(type: :plan_start, plan: nil)
+
+      results = outputter.spin do
+        pal.lookup(
+          key,
+          targets,
+          inventory,
+          executor,
+          config.concurrency
+        )
+      end
+
+      executor.shutdown
+      outputter.print_result_set(results)
+
+      results.ok ? 0 : 1
+    end
+
     def run_plan(plan_name, plan_arguments, nodes, options)
       unless nodes.empty?
         if plan_arguments['nodes'] || plan_arguments['targets']
@@ -929,20 +970,17 @@ module Bolt
     # the path is a Puppet file path and looks for the file in a module's files
     # directory.
     #
-    def find_file(path)
-      unless File.exist?(path) || Pathname.new(path).absolute?
-        modulepath = Bolt::Config::Modulepath.new(config.modulepath)
-        modules    = Bolt::Module.discover(modulepath.full_modulepath, config.project)
-        mod, file = path.split(File::SEPARATOR, 2)
-
-        if modules[mod]
-          @logger.debug("Did not find file at #{File.expand_path(path)}, checking in module '#{mod}'")
-          path = File.join(modules[mod].path, 'files', file)
-        end
+    def find_file(path, future_file_paths)
+      return path if File.exist?(path) || Pathname.new(path).absolute?
+      modulepath = Bolt::Config::Modulepath.new(config.modulepath)
+      modules    = Bolt::Module.discover(modulepath.full_modulepath, config.project)
+      mod, file = path.split(File::SEPARATOR, 2)
+
+      if modules[mod]
+        @logger.debug("Did not find file at #{File.expand_path(path)}, checking in module '#{mod}'")
+        found = Bolt::Util.find_file_in_module(modules[mod].path, file || "", future_file_paths)
+        path = found.nil? ? File.join(modules[mod].path, 'files', file) : found
       end
-
-      Bolt::Util.validate_file('script', path)
-
       path
     end
 

data/lib/bolt/outputter/human.rb

@@ -174,12 +174,16 @@ module Bolt
             @stream.puts(remove_trail(indent(2, result.message)))
           end
 
-          # Use special handling if the result looks like a command or script result
-          if result.generic_value.keys == %w[stdout stderr merged_output exit_code]
+          case result.action
+          when 'command', 'script'
             safe_value = result.safe_value
             @stream.puts(indent(2, safe_value['merged_output'])) unless safe_value['merged_output'].strip.empty?
-          elsif result.generic_value.any?
-            @stream.puts(indent(2, ::JSON.pretty_generate(result.generic_value)))
+          when 'lookup'
+            @stream.puts(indent(2, result['value']))
+          else
+            if result.generic_value.any?
+              @stream.puts(indent(2, ::JSON.pretty_generate(result.generic_value)))
+            end
           end
         end
       end

data/lib/bolt/outputter/json.rb

@@ -83,6 +83,10 @@ module Bolt
         @stream.puts result.to_json
       end
 
+      def print_result_set(result_set)
+        @stream.puts result_set.to_json
+      end
+
       def print_topics(topics)
         print_table('topics' => topics)
       end

data/lib/bolt/pal.rb

@@ -615,5 +615,50 @@ module Bolt
     rescue Bolt::Error => e
       Bolt::PlanResult.new(e, 'failure')
     end
+
+    def lookup(key, targets, inventory, executor, _concurrency)
+      # Install the puppet-agent package and collect facts. Facts are
+      # automatically added to the targets.
+      in_plan_compiler(executor, inventory, nil) do |compiler|
+        compiler.call_function('apply_prep', targets)
+      end
+
+      overrides = {
+        bolt_inventory: inventory,
+        bolt_project:   @project
+      }
+
+      # Do a lookup with a catalog compiler, which uses the 'hierarchy' key in
+      # Hiera config.
+      results = targets.map do |target|
+        node = Puppet::Node.from_data_hash(
+          'name'       => target.name,
+          'parameters' => { 'clientcert' => target.name }
+        )
+
+        trusted = Puppet::Context::TrustedInformation.local(node).to_h
+
+        env_conf = {
+          modulepath: @modulepath.full_modulepath,
+          facts:      target.facts,
+          variables:  target.vars
+        }
+
+        with_puppet_settings do
+          Puppet::Pal.in_tmp_environment(target.name, **env_conf) do |pal|
+            Puppet.override(overrides) do
+              Puppet.lookup(:pal_current_node).trusted_data = trusted
+              pal.with_catalog_compiler do |compiler|
+                Bolt::Result.for_lookup(target, key, compiler.call_function('lookup', key))
+              rescue StandardError => e
+                Bolt::Result.from_exception(target, e)
+              end
+            end
+          end
+        end
+      end
+
+      Bolt::ResultSet.new(results)
+    end
   end
 end

data/lib/bolt/result.rb

@@ -28,6 +28,11 @@ module Bolt
       %w[file line].zip(position).to_h.compact
     end
 
+    def self.for_lookup(target, key, value)
+      val = { 'value' => value }
+      new(target, value: val, action: 'lookup', object: key)
+    end
+
     def self.for_command(target, value, action, command, position)
       details = create_details(position)
       unless value['exit_code'] == 0

data/lib/bolt/util.rb

@@ -85,6 +85,66 @@ module Bolt
         Bolt::Config.user_path && !File.exist?(first_runs_free)
       end
 
+      # If Puppet is loaded, we aleady have the path to the module and should
+      # just get it. This takes the path to a file provided by the user and a
+      # Puppet Parser scope object and tries to find the file, either as an
+      # absolute path or Puppet module syntax lookup. Returns the path to the
+      # file if found, or nil.
+      #
+      def find_file_from_scope(file, scope, fallback = false)
+        # If we got an absolute path, just return that.
+        return file if Pathname.new(file).absolute?
+
+        module_name, file_pattern = Bolt::Util.split_path(file)
+        # Get the absolute path to the module root from the scope
+        mod_path = scope.compiler.environment.module(module_name)&.path
+
+        # Search the module for the file, falling back to new-style paths if enabled.
+        find_file_in_module(mod_path, file_pattern, fallback) if mod_path
+      end
+
+      # This method is used by Bolt to find files when provided a
+      # module-style path without loading Puppet. It takes the absolute path to
+      # the module root and the module-style path minus the module name and
+      # searches subdirectories in the module in order of precedence.
+      #
+      def find_file_in_module(module_path, module_file, fallback = false)
+        # If the first part of the path is 'scripts' or 'files', the path may
+        # be a new-style file location and should fall back to the new path.
+        subdir_or_file = split_path(module_file).first
+        case subdir_or_file
+          # For any subdirs that may indicate the user passed a new-style path,
+          # first look in 'mymod/files/<relative_path>' (old-style) then fall
+          # back to 'mymod/<relative_path>' (new-style) if enabled.
+        when 'scripts', 'files'
+          search_module(module_path, module_file, fallback)
+        else
+          # If the path definitely isn't new-style, only look in the 'files/'
+          # directory.
+          search_module(module_path, module_file)
+        end
+      end
+
+      # This searches a module for files under 'files/' or 'scripts/',
+      # optionally falling back to the new style of file loading. It takes the
+      # absolute path to the module root, the relative path provided by the
+      # user, and whether to fall back to the new-style script loading if the
+      # file isn't found in 'files/'.
+      #
+      private def search_module(module_path, module_file, fallback = false)
+        if File.exist?(File.join(module_path, 'files', module_file))
+          File.join(module_path, 'files', module_file)
+        elsif File.exist?(File.join(module_path, module_file)) && fallback
+          File.join(module_path, module_file)
+        end
+      end
+
+      # Copied directly from puppet/lib/puppet/parser/files.rb
+      #
+      def split_path(path)
+        path.split(File::SEPARATOR, 2)
+      end
+
       # Accepts a path with either 'plans' or 'tasks' in it and determines
       # the name of the module
       def module_name(path)

data/lib/bolt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 3.7.1
+  version: 3.8.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-26 00:00:00.000000000 Z
+date: 2021-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable