bolt 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7e3c1e13c0b81acdf948d563eb5acc20710ba52c6aacd14580defbb722fa6ca
-  data.tar.gz: 5a382bffe6ac5eb12e7214a5f0f64581366a4e224f0a1968e5db8a656994f5a1
+  metadata.gz: 4c52a68237c35477a0e8a18b0ac4114476eaf6c49a21d454d7d2ae25031db44c
+  data.tar.gz: 73502d5faa64ef267863c436aea928af45991b8571a280f87f3fbcd888a2132c
 SHA512:
-  metadata.gz: 5793f401349ef2a8985b97c4938cf61497c51abb39fcd65ca2fbc3c4173719366d659eeb302fb145e1e198e415ed62b50728743f0bf98440b9d8d837ce28617c
-  data.tar.gz: c9dc1835008deda159c9e317134dc68c67a24d5cab366cf72d608fd067d854d58ce1084f289aacb7764008a085d26363c82b186b6885ecf2bdab6ddf0eecc464
+  metadata.gz: d2bf04c7a4e6a5f72a7f92eb66f0937f5adb9767babf15639fbbe6f4b1b368996f2abeddfbc4a82e146124fce04282aecdf769a5475543b7b480e4fbf9865067
+  data.tar.gz: 96ace6cbf150ce44057a48f5e33571ebcc2255abecdf2ba70591b184776175ad8777a0dac6ffbef75740f60a84f92e205c3f915b5919d866b758bb64d0773523

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'bolt/task'
 
 Puppet::Functions.create_function(:apply_prep) do
   dispatch :apply_prep do
@@ -12,8 +13,10 @@ Puppet::Functions.create_function(:apply_prep) do
   end
 
   def run_task(executor, targets, name, args = {})
-    task = script_compiler.task_signature(name)&.task
-    raise Bolt::Error.new("#{name} could not be found", 'bolt/apply-prep') unless task
+    tasksig = script_compiler.task_signature(name)
+    raise Bolt::Error.new("#{name} could not be found", 'bolt/apply-prep') unless tasksig
+
+    task = Bolt::Task.new(tasksig.task_hash)
     results = executor.run_task(targets, task, args)
     raise Bolt::RunFailure.new(results, 'run_task', task.name) unless results.ok?
     results

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

@@ -2,12 +2,16 @@
 
 require 'bolt/error'
 
-# Makes a query to puppetdb using Bolt's PuppetDB client.
+# Makes a query to {https://puppet.com/docs/puppetdb/latest/index.html puppetdb}
+# using Bolt's PuppetDB client.
 Puppet::Functions.create_function(:puppetdb_query) do
+  # rubocop:disable Metrics/LineLength
   # @param query A PQL query.
+  #   {https://puppet.com/docs/puppetdb/latest/api/query/tutorial-pql.html Learn more about Puppet's query language, PQL}
   # @return Results of the PuppetDB query.
   # @example Request certnames for all nodes
   #   puppetdb_query('nodes[certname] {}')
+  # rubocop:enable Metrics/LineLength
   dispatch :make_query do
     param 'Variant[String, Array[Data]]', :query
     return_type 'Array[Data]'

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

@@ -2,6 +2,7 @@
 
 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.
@@ -101,11 +102,7 @@ Puppet::Functions.create_function(:run_task) do
     # and the local-validation option is set to false for all of them
     if !targets.empty? && targets.all? { |t| t.protocol == 'pcp' && t.options['local-validation'] == false }
       # create a fake task
-      task = Puppet::Pops::Types::TypeFactory.task.from_hash(
-        'name'            => task_name,
-        'implementations' => [{ 'name' => '', 'path' => '' }],
-        'supports_noop'   => true
-      )
+      task = Bolt::Task.new(name: task_name, files: [{ '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)
@@ -117,7 +114,7 @@ Puppet::Functions.create_function(:run_task) do
         raise with_stack(:TYPE_MISMATCH, mismatch_message)
       end || (raise with_stack(:TYPE_MISMATCH, 'Task parameters do not match'))
 
-      task = task_signature.task
+      task = Bolt::Task.new(task_signature.task_hash)
     end
 
     unless Puppet::Pops::Types::TypeFactory.data.instance?(use_args)
@@ -133,9 +130,9 @@ Puppet::Functions.create_function(:run_task) do
 
     # Wrap parameters marked with '"sensitive": true' in the task metadata with a
     # Sensitive wrapper type. This way it's not shown in logs.
-    if task.parameters
+    if (params = task.parameters)
       use_args.each do |k, v|
-        if task.parameters[k] && task.parameters[k]['sensitive']
+        if params[k] && params[k]['sensitive']
           use_args[k] = Puppet::Pops::Types::PSensitiveType::Sensitive.new(v)
         end
       end

data/lib/bolt/applicator.rb

@@ -40,16 +40,18 @@ module Bolt
     def custom_facts_task
       @custom_facts_task ||= begin
         path = File.join(libexec, 'custom_facts.rb')
-        impl = { 'name' => 'custom_facts.rb', 'path' => path, 'requirements' => [], 'supports_noop' => true }
-        Task.new(name: 'custom_facts', implementations: [impl], input_method: 'stdin')
+        file = { 'name' => 'custom_facts.rb', 'path' => path }
+        metadata = { 'supports_noop' => true, 'input_method' => 'stdin' }
+        Bolt::Task.new(name: 'apply_helpers::custom_facts', files: [file], metadata: metadata)
       end
     end
 
     def catalog_apply_task
       @catalog_apply_task ||= begin
         path = File.join(libexec, 'apply_catalog.rb')
-        impl = { 'name' => 'apply_catalog.rb', 'path' => path, 'requirements' => [], 'supports_noop' => true }
-        Task.new(name: 'apply_catalog', implementations: [impl], input_method: 'stdin')
+        file = { 'name' => 'apply_catalog.rb', 'path' => path }
+        metadata = { 'supports_noop' => true, 'input_method' => 'stdin' }
+        Bolt::Task.new(name: 'apply_helpers::apply_catalog', files: [file], metadata: metadata)
       end
     end
 
@@ -103,7 +105,7 @@ module Bolt
 
     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) }
+        data = File.open(File.path(hiera_config), "r:UTF-8") { |f| YAML.safe_load(f.read, [Symbol]) }
         unless data['version'] == 5
           raise Bolt::ParseError, "Hiera v5 is required, found v#{data['version'] || 3} in #{hiera_config}"
         end
@@ -197,9 +199,10 @@ module Bolt
             @executor.with_node_logging("Applying manifest block", batch) do
               arguments = { 'catalog' => future.value, 'plugins' => plugins, '_noop' => options['_noop'] }
               raise future.reason if future.rejected?
-              result = transport.batch_task(batch, catalog_apply_task, arguments, options, &notify)
-              result = provide_puppet_missing_errors(result)
-              identify_resource_failures(result)
+              results = transport.batch_task(batch, catalog_apply_task, arguments, options, &notify)
+              Array(results).map do |result|
+                identify_resource_failures(provide_puppet_missing_errors(result))
+              end
             end
           end
         end

data/lib/bolt/boltdir.rb

@@ -12,13 +12,21 @@ module Bolt
       Boltdir.new(File.join('~', '.puppetlabs', 'bolt'))
     end
 
+    # Search recursively up the directory hierarchy for the Boltdir. Look for a
+    # directory called Boltdir or a file called bolt.yaml (for a control repo
+    # type Boltdir). Otherwise, repeat the check on each directory up the
+    # hierarchy, falling back to the default if we reach the root.
     def self.find_boltdir(dir)
-      local_boltdir = Pathname.new(dir).ascend do |path|
-        boltdir = path + BOLTDIR_NAME
-        break new(boltdir) if boltdir.directory?
+      dir = Pathname.new(dir)
+      if (dir + BOLTDIR_NAME).directory?
+        new(dir + BOLTDIR_NAME)
+      elsif (dir + 'bolt.yaml').file?
+        new(dir)
+      elsif dir.root?
+        default_boltdir
+      else
+        find_boltdir(dir.parent)
       end
-
-      local_boltdir || default_boltdir
     end
 
     def initialize(path)

data/lib/bolt/catalog.rb

@@ -5,13 +5,11 @@ require 'bolt/puppetdb'
 
 Bolt::PAL.load_puppet
 
-require 'bolt/catalog/compiler'
-require 'bolt/catalog/loaders'
 require 'bolt/catalog/logging'
 
 module Bolt
   class Catalog
-    def with_puppet_settings(hiera_config)
+    def with_puppet_settings(hiera_config = {})
       Dir.mktmpdir('bolt') do |dir|
         cli = []
         Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
@@ -28,30 +26,15 @@ module Bolt
       end
     end
 
-    def setup_node(node, trusted)
-      facts = Puppet.lookup(:pal_facts)
-      node_facts = Puppet::Node::Facts.new(Puppet[:node_name_value], facts)
-      node.fact_merge(node_facts)
-
-      node.parameters = node.parameters.merge(Puppet.lookup(:pal_variables))
-      node.trusted_data = trusted
-    end
-
-    def compile_node(node)
-      # Add boltlib to system loaders so modules can use its functions without an
-      # explicit dependency.
-      node.environment.loaders = Bolt::Catalog::BoltLoaders.new(node.environment)
-
-      compiler = Puppet::Parser::BoltCompiler.new(node)
-      compiler.compile(&:to_resource)
-    end
-
     def generate_ast(code)
       with_puppet_settings do
-        Puppet::Pal.in_tmp_environment("bolt_parse") do |_pal|
-          node = Puppet.lookup(:pal_current_node)
-          compiler = Puppet::Parser::BoltCompiler.new(node)
-          compiler.dump_ast(compiler.parse_string(code))
+        Puppet::Pal.in_tmp_environment("bolt_parse") do |pal|
+          pal.with_catalog_compiler do |compiler|
+            ast = compiler.parse_string(code)
+            Puppet::Pops::Serialization::ToDataConverter.convert(ast,
+                                                                 rich_data: true,
+                                                                 symbol_to_string: true)
+          end
         end
       end
     end
@@ -69,32 +52,24 @@ module Bolt
     def compile_catalog(request)
       pal_main = request['code_ast'] || request['code_string']
       target = request['target']
-
       pdb_client = Bolt::PuppetDB::Client.new(Bolt::PuppetDB::Config.new(request['pdb_config']))
 
       with_puppet_settings(request['hiera_config']) do
-        Puppet[:code] = ''
+        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|
-          node = Puppet.lookup(:pal_current_node)
-
-          # Ensure files that custom facts and types/providers depend on can be loaded
-          node.environment.each_plugin_directory do |dir|
-            $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
-          end
-
-          setup_node(node, target["trusted"])
-
-          Puppet.override(pal_main: pal_main,
-                          bolt_pdb_client: pdb_client,
-                          bolt_inventory:
-                          setup_inventory(request['inventory'])) do
-            compile_node(node)
+        Puppet::Pal.in_tmp_environment('bolt_catalog',
+                                       modulepath: request["modulepath"] || [],
+                                       facts: target["facts"] || {},
+                                       variables: target["variables"] || {}) do |pal|
+          Puppet.override(bolt_pdb_client: pdb_client,
+                          bolt_inventory: setup_inventory(request['inventory'])) do
+            Puppet.lookup(:pal_current_node).trusted_data = target['trusted']
+            pal.with_catalog_compiler do |compiler|
+              ast = Puppet::Pops::Serialization::FromDataConverter.convert(pal_main)
+              compiler.evaluate(ast)
+              compiler.compile_additions
+              compiler.with_json_encoding(&:encode)
+            end
           end
         end
       end

data/lib/bolt/config.rb

@@ -60,17 +60,7 @@ module Bolt
     end
 
     def self.from_boltdir(boltdir, overrides = {})
-      # *Optionally* load the boltdir config file, and fall back to the legacy
-      # config if that isn't found. Because logging is built in to the
-      # legacy_conf method, we don't want to look that up unless we need it.
-      configs = if boltdir.config_file.exist?
-                  [boltdir.config_file]
-                else
-                  [legacy_conf]
-                end
-
-      data = Bolt::Util.read_config_file(nil, configs, 'config') || {}
-
+      data = Bolt::Util.read_config_file(nil, [boltdir.config_file], 'config') || {}
       new(boltdir, data, overrides)
     end
 
@@ -174,21 +164,6 @@ module Bolt
     end
     private :update_from_file
 
-    # TODO: This is deprecated in 0.21.0 and can be removed in release 0.22.0.
-    def self.legacy_conf
-      root_path = File.expand_path(File.join('~', '.puppetlabs'))
-      legacy_paths = [File.join(root_path, 'bolt.yaml'), File.join(root_path, 'bolt.yml')]
-      legacy_conf = legacy_paths.find { |path| File.exist?(path) }
-      found_legacy_conf = !!legacy_conf
-      legacy_conf ||= legacy_paths[0]
-      if found_legacy_conf
-        correct_path = Bolt::Boltdir.default_boltdir.config_file
-        msg = "Found configfile at deprecated location #{legacy_conf}. Global config should be in #{correct_path}"
-        Logging.logger[self].warn(msg)
-      end
-      legacy_conf
-    end
-
     def apply_overrides(options)
       %i[concurrency transport format trace modulepath inventoryfile color].each do |key|
         send("#{key}=", options[key]) if options.key?(key)

data/lib/bolt/executor.rb

@@ -224,7 +224,7 @@ module Bolt
         arguments['_task'] = task.name
 
         results = batch_execute(targets) do |transport, batch|
-          with_node_logging("Running task #{task.name} with '#{arguments}' via #{task.input_method}", batch) do
+          with_node_logging("Running task #{task.name} with '#{arguments}'", batch) do
             transport.batch_task(batch, task, arguments, options, &notify)
           end
         end

data/lib/bolt/outputter.rb

@@ -18,15 +18,6 @@ module Bolt
       @trace = trace
       @stream = stream
     end
-
-    # This method replaces data types tha have the name 'Data'
-    # with the string 'Any'
-    # This was a problem when using 'bolt task show <task_name>'
-    def replace_data_type(params)
-      params.map do |_, v|
-        v['type'] = 'Any' if v['type'].to_s == 'Data'
-      end
-    end
   end
 end
 

data/lib/bolt/outputter/human.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'terminal-table'
+require 'bolt/pal'
+
 module Bolt
   class Outputter
     class Human < Bolt::Outputter
@@ -119,26 +121,31 @@ module Bolt
         task_info = +""
         usage = +"bolt task run --nodes <node-name> #{task['name']}"
 
-        if task['parameters']
-          replace_data_type(task['parameters'])
-          task['parameters'].each do |k, v|
-            pretty_params << "- #{k}: #{v['type']}\n"
-            pretty_params << "    #{v['description']}\n" if v['description']
-            usage << if v['type'].is_a?(Puppet::Pops::Types::POptionalType)
-                       " [#{k}=<value>]"
-                     else
-                       " #{k}=<value>"
-                     end
-          end
+        task['metadata']['parameters']&.each do |k, v|
+          pretty_params << "- #{k}: #{v['type'] || 'Any'}\n"
+          pretty_params << "    #{v['description']}\n" if v['description']
+          usage << if v['type'].is_a?(Puppet::Pops::Types::POptionalType)
+                     " [#{k}=<value>]"
+                   else
+                     " #{k}=<value>"
+                   end
         end
 
-        usage << " [--noop]" if task['supports_noop']
+        usage << " [--noop]" if task['metadata']['supports_noop']
 
         task_info << "\n#{task['name']}"
-        task_info << " - #{task['description']}" if task['description']
+        task_info << " - #{task['metadata']['description']}" if task['metadata']['description']
         task_info << "\n\n"
         task_info << "USAGE:\n#{usage}\n\n"
-        task_info << "PARAMETERS:\n#{pretty_params}\n" if task['parameters']
+        task_info << "PARAMETERS:\n#{pretty_params}\n" unless pretty_params.empty?
+        task_info << "MODULE:\n"
+
+        path = task['files'][0]['path'].chomp("/tasks/#{task['files'][0]['name']}")
+        task_info << if path.start_with?(Bolt::PAL::MODULES_PATH)
+                       "built-in module"
+                     else
+                       path
+                     end
         @stream.puts(task_info)
       end
 
@@ -158,6 +165,14 @@ module Bolt
         plan_info << "\n\n"
         plan_info << "USAGE:\n#{usage}\n\n"
         plan_info << "PARAMETERS:\n#{pretty_params}\n" if plan['parameters']
+        plan_info << "MODULE:\n"
+
+        path = plan['module']
+        plan_info << if path.start_with?(Bolt::PAL::MODULES_PATH)
+                       "built-in module"
+                     else
+                       path
+                     end
         @stream.puts(plan_info)
       end
 

data/lib/bolt/outputter/json.rb

@@ -44,11 +44,22 @@ module Bolt
       end
 
       def print_task_info(task)
-        replace_data_type(task['parameters'])
+        path = task['files'][0]['path'].chomp("/tasks/#{task['files'][0]['name']}")
+        task['module_dir'] = if path.start_with?(Bolt::PAL::MODULES_PATH)
+                               "built-in module"
+                             else
+                               path
+                             end
         @stream.puts task.to_json
       end
 
       def print_plan_info(plan)
+        path = plan.delete('module')
+        plan['module_dir'] = if path.start_with?(Bolt::PAL::MODULES_PATH)
+                               "built-in module"
+                             else
+                               path
+                             end
         @stream.puts plan.to_json
       end
 

data/lib/bolt/pal.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
+require 'bolt/applicator'
 require 'bolt/executor'
 require 'bolt/error'
 require 'bolt/plan_result'
 require 'bolt/util'
-require 'bolt/applicator'
 
 module Bolt
   class PAL
@@ -182,7 +182,7 @@ module Bolt
         tasks = compiler.list_tasks
         tasks.map(&:name).sort.map do |task_name|
           task_sig = compiler.task_signature(task_name)
-          [task_name, task_sig.task.description]
+          [task_name, task_sig.task_hash['metadata']['description']]
         end
       end
     end
@@ -190,15 +190,15 @@ module Bolt
     def parse_params(type, object_name, params)
       in_bolt_compiler do |compiler|
         if type == 'task'
-          param_spec = compiler.task_signature(object_name)&.task_hash
+          param_spec = compiler.task_signature(object_name)&.task_hash&.dig('parameters')
         elsif type == 'plan'
           plan = compiler.plan_signature(object_name)
-          param_spec = plan_hash(object_name, plan) if plan
+          param_spec = plan.params_type.elements&.each_with_object({}) { |t, h| h[t.name] = t.value_type } if plan
         end
         param_spec ||= {}
 
         params.each_with_object({}) do |(name, str), acc|
-          type = param_spec.dig('parameters', name, 'type')
+          type = param_spec[name]
           begin
             parsed = JSON.parse(str, quirks_mode: true)
             # The type may not exist if the module is remote on orch or if a task
@@ -227,7 +227,7 @@ module Bolt
         raise Bolt::Error.new(Bolt::Error.unknown_task(task_name), 'bolt/unknown-task')
       end
 
-      task.task_hash
+      task.task_hash.reject { |k, _| k == 'parameters' }
     end
 
     def list_plans
@@ -236,9 +236,8 @@ module Bolt
       end
     end
 
-    # This converts a plan signature object into a format approximating the
-    # task_hash of a task_signature. Must be called from within bolt compiler
-    # to pickup type aliases used in the plan signature.
+    # This converts a plan signature object into a format used by the outputter.
+    # Must be called from within bolt compiler to pickup type aliases used in the plan signature.
     def plan_hash(plan_name, plan)
       elements = plan.params_type.elements || []
       parameters = elements.each_with_object({}) do |param, acc|
@@ -250,11 +249,14 @@ module Bolt
         'parameters' => parameters
       }
     end
+    private :plan_hash
 
     def get_plan_info(plan_name)
       plan_info = in_bolt_compiler do |compiler|
         plan = compiler.plan_signature(plan_name)
-        plan_hash(plan_name, plan) if plan
+        hash = plan_hash(plan_name, plan) if plan
+        hash['module'] = plan.instance_variable_get(:@plan_func).loader.parent.path if plan
+        hash
       end
 
       if plan_info.nil?