bolt 2.40.2 → 3.1.0

data/lib/bolt/transport/local.rb

@@ -11,18 +11,10 @@ module Bolt
       end
 
       def with_connection(target)
-        if target.transport_config['bundled-ruby'] || target.name == 'localhost'
+        if target.transport_config['bundled-ruby']
           target.set_local_defaults
         end
 
-        if target.name != 'localhost' &&
-           !target.transport_config.key?('bundled-ruby')
-          msg = "The local transport will default to using Bolt's Ruby interpreter and "\
-            "setting the 'puppet-agent' feature in Bolt 3.0. Enable or disable these "\
-            "defaults by setting 'bundled-ruby' in the local transport config."
-          Bolt::Logger.warn_once('local default config', msg)
-        end
-
         yield Connection.new(target)
       end
     end

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

@@ -21,7 +21,7 @@ module Bolt
 
           @logger = logger
           @key = self.class.get_key(opts)
-          client_opts = opts.slice('token-file', 'cacert', 'job-poll-interval', 'job-poll-timeout')
+          client_opts = opts.slice('token-file', 'cacert', 'job-poll-interval', 'job-poll-timeout', 'read-timeout')
 
           if opts['service-url']
             uri = Addressable::URI.parse(opts['service-url'])

data/lib/bolt/transport/ssh.rb

@@ -23,8 +23,7 @@ module Bolt
 
       def with_connection(target)
         if target.transport_config['ssh-command'] && !target.transport_config['native-ssh']
-          Bolt::Logger.warn_once("ssh-command and native-ssh conflict",
-                                 "native-ssh must be true to use ssh-command")
+          Bolt::Logger.warn_once("native_ssh_disabled", "native-ssh must be true to use ssh-command")
         end
 
         conn = if target.transport_config['native-ssh']

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

@@ -34,7 +34,7 @@ module Bolt
             begin
               Bolt::Util.validate_file('ssh key', target.options['private-key'])
             rescue Bolt::FileError => e
-              @logger.warn(e.msg)
+              Bolt::Logger.warn("invalid_ssh_key", e.msg)
             end
           end
         end

data/lib/bolt/validator.rb

@@ -147,7 +147,7 @@ module Bolt
         message += " at '#{path}'" if @path.any?
         message += " at #{@location}" if @location
         message += "."
-        @warnings << message
+        @warnings << { id: 'unknown_option', msg: message }
       end
     end
 
@@ -160,7 +160,7 @@ module Bolt
         message  = "Option '#{path}' "
         message += "at #{@location} " if @location
         message += "is deprecated. #{definition[:_deprecation]}"
-        @deprecations << { option: key, message: message }
+        @deprecations << { id: "#{key}_option", msg: message }
       end
     end
 

data/lib/bolt/version.rb

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

data/lib/bolt_server/config.rb

@@ -9,7 +9,7 @@ module BoltServer
     def config_keys
       super + %w[concurrency cache-dir file-server-conn-timeout
                  file-server-uri projects-dir environments-codedir
-                 environmentpath basemodulepath]
+                 environmentpath basemodulepath builtin-content-dir]
     end
 
     def env_keys

data/lib/bolt_server/transport_app.rb

@@ -133,7 +133,14 @@ module BoltServer
       task_data = body['task']
       task = Bolt::Task::PuppetServer.new(task_data['name'], task_data['metadata'], task_data['files'], @file_cache)
       parameters = body['parameters'] || {}
-      [@executor.run_task(target, task, parameters), nil]
+      task_result = @executor.run_task(target, task, parameters)
+      task_result.each do |result|
+        value = result.value
+        next unless value.is_a?(Hash)
+        next unless value.key?('_sensitive')
+        value['_sensitive'] = value['_sensitive'].unwrap
+      end
+      [task_result, nil]
     end
 
     def run_command(target, body)
@@ -275,14 +282,19 @@ module BoltServer
       Bolt::Config.from_project(project, { log: { 'bolt-debug.log' => 'disable' } })
     end
 
+    def pal_from_project_bolt_config(bolt_config)
+      modulepath_object = Bolt::Config::Modulepath.new(
+        bolt_config.modulepath,
+        boltlib_path: [PE_BOLTLIB_PATH, Bolt::Config::Modulepath::BOLTLIB_PATH],
+        builtin_content_path: @config['builtin-content-dir']
+      )
+      Bolt::PAL.new(modulepath_object, nil, nil, nil, nil, nil, bolt_config.project)
+    end
+
     def in_bolt_project(versioned_project)
       @pal_mutex.synchronize do
         bolt_config = config_from_project(versioned_project)
-        modulepath_object = Bolt::Config::Modulepath.new(
-          bolt_config.modulepath,
-          boltlib_path: [PE_BOLTLIB_PATH, Bolt::Config::Modulepath::BOLTLIB_PATH]
-        )
-        pal = Bolt::PAL.new(modulepath_object, nil, nil, nil, nil, nil, bolt_config.project)
+        pal = pal_from_project_bolt_config(bolt_config)
         context = {
           pal: pal,
           config: bolt_config
@@ -350,8 +362,8 @@ module BoltServer
       }
     end
 
-    def allowed_helper(metadata, allowlist)
-      allowed = allowlist.nil? || allowlist.include?(metadata['name']) ? true : false
+    def allowed_helper(pal, metadata, allowlist)
+      allowed = !pal.filter_content([metadata['name']], allowlist).empty?
       metadata.merge({ 'allowed' => allowed })
     end
 
@@ -365,21 +377,27 @@ module BoltServer
       plans.map { |plan_name| { 'name' => plan_name } }
     end
 
-    def file_metadatas(pal, module_name, file)
-      pal.in_bolt_compiler do
-        mod = Puppet.lookup(:current_environment).module(module_name)
-        raise ArgumentError, "`module_name`: #{module_name} does not exist" unless mod
-        abs_file_path = mod.file(file)
-        raise ArgumentError, "`file`: #{file} does not exist inside the module's 'files' directory" unless abs_file_path
-        fileset = Puppet::FileServing::Fileset.new(abs_file_path, 'recurse' => 'yes')
-        Puppet::FileServing::Fileset.merge(fileset).collect do |relative_file_path, base_path|
-          metadata = Puppet::FileServing::Metadata.new(base_path, relative_path: relative_file_path)
-          metadata.checksum_type = 'sha256'
-          metadata.links = 'follow'
-          metadata.collect
-          metadata.to_data_hash
+    def file_metadatas(versioned_project, module_name, file)
+      abs_file_path = @pal_mutex.synchronize do
+        bolt_config = config_from_project(versioned_project)
+        pal = pal_from_project_bolt_config(bolt_config)
+        pal.in_bolt_compiler do
+          mod = Puppet.lookup(:current_environment).module(module_name)
+          raise ArgumentError, "`module_name`: #{module_name} does not exist" unless mod
+          mod.file(file)
         end
       end
+
+      raise ArgumentError, "`file`: #{file} does not exist inside the module's 'files' directory" unless abs_file_path
+
+      fileset = Puppet::FileServing::Fileset.new(abs_file_path, 'recurse' => 'yes')
+      Puppet::FileServing::Fileset.merge(fileset).collect do |relative_file_path, base_path|
+        metadata = Puppet::FileServing::Metadata.new(base_path, relative_path: relative_file_path)
+        metadata.checksum_type = 'sha256'
+        metadata.links = 'follow'
+        metadata.collect
+        metadata.to_data_hash
+      end
     end
 
     get '/' do
@@ -519,7 +537,7 @@ module BoltServer
       return MISSING_VERSIONED_PROJECT_RESPONSE if params['versioned_project'].nil?
       in_bolt_project(params['versioned_project']) do |context|
         plan_info = pe_plan_info(context[:pal], params[:module_name], params[:plan_name])
-        plan_info = allowed_helper(plan_info, context[:config].project.plans)
+        plan_info = allowed_helper(context[:pal], plan_info, context[:config].project.plans)
         [200, plan_info.to_json]
       end
     rescue Bolt::Error => e
@@ -549,7 +567,7 @@ module BoltServer
           'versioned_project' => params['versioned_project']
         }
         task_info = pe_task_info(context[:pal], params[:module_name], params[:task_name], ps_parameters)
-        task_info = allowed_helper(task_info, context[:config].project.tasks)
+        task_info = allowed_helper(context[:pal], task_info, context[:config].project.tasks)
         [200, task_info.to_json]
       end
     rescue Bolt::Error => e
@@ -589,7 +607,7 @@ module BoltServer
         plans_response = plan_list(context[:pal])
 
         # Dig in context for the allowlist of plans from project object
-        plans_response.map! { |metadata| allowed_helper(metadata, context[:config].project.plans) }
+        plans_response.map! { |metadata| allowed_helper(context[:pal], metadata, context[:config].project.plans) }
 
         # We structure this array of plans to be an array of hashes so that it matches the structure
         # returned by the puppetserver API that serves data like this. Structuring the output this way
@@ -625,7 +643,7 @@ module BoltServer
         tasks_response = task_list(context[:pal])
 
         # Dig in context for the allowlist of tasks from project object
-        tasks_response.map! { |metadata| allowed_helper(metadata, context[:config].project.tasks) }
+        tasks_response.map! { |metadata| allowed_helper(context[:pal], metadata, context[:config].project.tasks) }
 
         # We structure this array of tasks to be an array of hashes so that it matches the structure
         # returned by the puppetserver API that serves data like this. Structuring the output this way
@@ -641,12 +659,11 @@ module BoltServer
     #
     # @param versioned_project [String] the versioned_project to fetch the file metadatas from
     get '/project_file_metadatas/:module_name/*' do
-      return MISSING_VERSIONED_PROJECT_RESPONSE if params['versioned_project'].nil?
-      in_bolt_project(params['versioned_project']) do |context|
-        file = params[:splat].first
-        metadatas = file_metadatas(context[:pal], params[:module_name], file)
-        [200, metadatas.to_json]
-      end
+      versioned_project = params['versioned_project']
+      return MISSING_VERSIONED_PROJECT_RESPONSE if versioned_project.nil?
+      file = params[:splat].first
+      metadatas = file_metadatas(versioned_project, params[:module_name], file)
+      [200, metadatas.to_json]
     rescue Bolt::Error => e
       [400, e.to_json]
     rescue ArgumentError => e

data/lib/bolt_spec/bolt_context.rb

@@ -130,11 +130,16 @@ module BoltSpec
       @executor ||= BoltSpec::Plans::MockExecutor.new(modulepath)
     end
 
-    # Override in your tests
+    # Overrides inventory for tests.
     def inventory_data
       {}
     end
 
+    # Overrides configuration for tests.
+    def config_data
+      {}
+    end
+
     def inventory
       @inventory ||= Bolt::Inventory.create_version(inventory_data, config.transport, config.transports, plugins)
     end
@@ -142,7 +147,7 @@ module BoltSpec
     # Override in your tests
     def config
       @config ||= begin
-        conf = Bolt::Config.default
+        conf = Bolt::Config.new(Bolt::Project.default_project, config_data)
         conf.modulepath = [modulepath].flatten
         conf
       end
@@ -161,7 +166,7 @@ module BoltSpec
     BoltSpec::Plans::MOCKED_ACTIONS.each do |action|
       # Allowed action stubs can be called up to be_called_times number of times
       define_method :"allow_#{action}" do |object|
-        executor.send(:"stub_#{action}", object).add_stub
+        executor.send(:"stub_#{action}", object).add_stub(inventory)
       end
 
       # Expected action stubs must be called exactly the expected number of times
@@ -172,7 +177,7 @@ module BoltSpec
 
       # This stub will catch any action call if there are no stubs specifically for that task
       define_method :"allow_any_#{action}" do
-        executor.send(:"stub_#{action}", :default).add_stub
+        executor.send(:"stub_#{action}", :default).add_stub(inventory)
       end
     end
 

data/lib/bolt_spec/plans.rb

@@ -5,119 +5,11 @@ require 'bolt_spec/plans/mock_executor'
 require 'bolt/pal'
 
 # These helpers are intended to be used for plan unit testing without calling
-# out to target nodes. It uses the BoltContext helper to set up a mock executor
+# out to targets. It uses the BoltContext helper to set up a mock executor
 # which allows calls to run_* functions to be stubbed for testing. The context
 # helper also loads Bolt datatypes and plan functions to be used by the code
 # being tested.
 #
-# Stub matching
-#
-# Stubs match invocations of run_* functions by default matching any call but
-# with_targets and with_params helpers can further restrict the stub to match
-# more exact invocations. It's possible a call to run_* could match multiple
-# stubs. In this case the mock executor will first check for stubs specifically
-# matching the task being run after which it will use the last stub that
-# matched
-#
-#
-# allow vs expect
-#
-# Stubs have two general modes bases on whether the test is making assertions
-# on whether function was called. Allow stubs allow the run_* invocation  to
-# be called any number of times while expect stubs will fail if no run_*
-# invocation matches them. The be_called_times(n) stub method can be used to
-# ensure an allow stub is not called more than n times or that an expect stub
-# is called exactly n times.
-#
-# Configuration
-#
-#  To configure Puppet and Bolt at the beginning of tests, add the following
-#  line to your spec_helper.rb:
-#
-#  BoltSpec::Plans.init
-#
-#  By default the plan helpers use the modulepath set up for rspec-puppet and
-#  an otherwise empty bolt config and inventory. To create your own values for
-#  these override the modulepath, config, or inventory methods.
-#
-# Sub-plan Execution
-#
-#  When testing a plan, often times those plans call other plans in order to
-#  build complex workflows. To support this we offer running in two different
-#  modes:
-#    execute_any_plan (default) - This mode will execute any plan that is encountered
-#      without having to be stubbed/mocked. This default mode allows for plan control
-#      flow to behave as normal. If you choose to stub/mock out a sub-plan in this mode
-#      that will be honored and the sub-plan will not be executed. We will use the modifiers
-#      on the stub to check for the conditions specified (example: be_called_times(3))
-#
-#    execute_no_plan - This mode will not execute a plans that it encounters. Instead, when
-#      a plan is encountered it will throw an error unless the plan is mocked out. This
-#      mode is useful for ensuring that there are no plans called that you do not expect.
-#      This plan requires authors to mock out all sub-plans that may be invoked when running
-#      tests.
-#
-#  TODO:
-#  - Allow description based stub matching
-#  - Better testing of plan errors
-#  - Better error collection around call counts. Show what stubs exists and more than a single failure
-#  - Allow stubbing with a block(at the double level? As a matched stub?)
-#  - package code so that it can be used for testing modules outside of this repo
-#  - set subject from describe and provide matchers similar to rspec puppets function tests
-#  - Allow specific plans to be executed when running in execute_no_plan mode.
-#
-#  MAYBE TODO?:
-#  - validate call expectations at the end of the example instead of in run_plan
-#  - resultset matchers to help testing canary like plans?
-#  - inventory matchers to help testing plans that change inventory
-#
-# Flags:
-# - execute_any_plan: execute any plan that is encountered unless it is mocked (default)
-# - execute_no_plan: throw an error if a plan is encountered that is not stubbed
-#
-# Stubs:
-# - allow_command(cmd), expect_command(cmd): expect the exact command
-# - allow_plan(plan), expect_plan(plan): expect the named plan
-# - allow_script(script), expect_script(script): expect the script as <module>/path/to/file
-# - allow_task(task), expect_task(task): expect the named task
-# - allow_download(file), expect_download(file): expect the identified source file
-# - allow_upload(file), expect_upload(file): expect the identified source file
-# - allow_apply_prep: allows `apply_prep` to be invoked in the plan but does not allow modifiers
-# - allow_apply: allows `apply` to be invoked in the plan but does not allow modifiers
-# - allow_out_message, expect_out_message: expect a message to be passed to out::message (only modifiers are
-#   be_called_times(n), with_params(params), and not_be_called)
-#
-# Stub modifiers:
-# - be_called_times(n): if allowed, fail if the action is called more than 'n' times
-#                       if expected, fail unless the action is called 'n' times
-# - not_be_called: fail if the action is called
-# - with_targets(targets): target or list of targets that you expect to be passed to the action
-#                          plan: does not support this modifier
-# - with_params(params): list of params and metaparams (or options) that you expect to be passed to the action.
-#                        Corresponds to the action's last argument.
-# - with_destination(dest): for upload_file and download_file, the expected destination path
-# - always_return(value): return a Bolt::ResultSet of Bolt::Result objects with the specified value Hash
-#                         plan: returns a Bolt::PlanResult with the specified value with a status of 'success'
-#                         command and script: only accept 'stdout' and 'stderr' keys
-#                         upload: does not support this modifier
-#                         download: does not support this modifier
-# - return_for_targets(targets_to_values): return a Bolt::ResultSet of Bolt::Result objects from the Hash mapping
-#                                          targets to their value Hashes
-#                                          command and script: only accept 'stdout' and 'stderr' keys
-#                                          upload: does not support this modifier
-#                                          download: does not support this modifier
-#                                          plan: does not support this modifier
-# - return(&block): invoke the block to construct a Bolt::ResultSet. The blocks parameters differ based on action
-#                   command: `{ |targets:, command:, params:| ... }`
-#                   plan: `{ |plan:, params:| ... }`
-#                   script: `{ |targets:, script:, params:| ... }`
-#                   task: `{ |targets:, task:, params:| ... }`
-#                   upload: `{ |targets:, source:, destination:, params:| ... }`
-#                   download: `{ |targets:, source:, destination:, params:| ... }`
-# - error_with(err): return a failing Bolt::ResultSet, with Bolt::Result objects with the identified err hash
-#                    plans will throw a Bolt::PlanFailure that will be returned as the value of
-#                    the Bolt::PlanResult object with a status of 'failure'.
-#
 # Example:
 #   describe "my_plan" do
 #     it 'should return' do

data/libexec/bolt_catalog

@@ -56,7 +56,7 @@ when "compile"
               else
                 e.message
               end
-    puts({ message: message }.to_json)
+    puts({ message: message, backtrace: e.backtrace }.to_json)
     exit 1
   rescue StandardError => e
     puts({ message: e.message }.to_json)

data/modules/aggregate/plans/count.pp

@@ -1,3 +1,24 @@
+# @summary
+#   Run a task, command, or script on targets and aggregate the results as
+#   a count of targets for each value of a key.
+#
+# This plan accepts an action and a list of targets. The action can be the name
+# of a task, a script, or a command to run. It will run the action on the
+# targets and aggregate the key/value pairs in each Result into a hash, mapping
+# the keys to a hash of each distinct value and how many targets returned that
+# value for the key.
+#
+# @param command
+#   The command to run. Mutually exclusive with script and task.
+# @param script
+#   The path to the script to run. Mutually exclusive with command and task.
+# @param task
+#   The name of the task to run. Mutually exclusive with command and script.
+# @param targets
+#   The list of targets to run the action on.
+# @param params
+#   A hash of parameters and options to pass to the `run_*` function
+#   associated with the action (e.g. run_task).
 plan aggregate::count(
   Optional[String[0]] $task = undef,
   Optional[String[0]] $command = undef,

data/modules/aggregate/plans/targets.pp

@@ -1,3 +1,24 @@
+# @summary
+#   Run a task, command, or script on targets and aggregate the results as
+#   the list of targets for each value of a key in the results.
+#
+# This plan accepts an action and a list of targets. The action can be the name
+# of a task, a script, or a command to run. It will run the action on the
+# targets and aggregate the key/value pairs in each Result into a hash, mapping
+# the keys to a hash of each distinct value and a list of targets returning that
+# value.
+#
+# @param command
+#   The command to run. Mutually exclusive with script and task.
+# @param script
+#   The path to the script to run. Mutually exclusive with command and task.
+# @param task
+#   The name of the task to run. Mutually exclusive with command and script.
+# @param targets
+#   The list of targets to run the action on.
+# @param params
+#   A hash of parameters and options to pass to the `run_*` function
+#   associated with the action (e.g. run_task).
 plan aggregate::targets(
   Optional[String[0]] $task = undef,
   Optional[String[0]] $command = undef,