bolt 3.8.1 → 3.11.0

data/lib/bolt_spec/plans/mock_executor.rb

@@ -17,13 +17,12 @@ module BoltSpec
 
     # Nothing on the executor is 'public'
     class MockExecutor
-      attr_reader :noop, :error_message, :in_parallel, :transports, :future
+      attr_reader :noop, :error_message, :transports, :future
       attr_accessor :run_as, :transport_features, :execute_any_plan
 
       def initialize(modulepath)
         @noop = false
         @run_as = nil
-        @in_parallel = false
         @future = {}
         @error_message = nil
         @allow_apply = false
@@ -38,6 +37,7 @@ module BoltSpec
         @execute_any_plan = true
         # plans that are allowed to be executed by the @executor_real
         @allowed_exec_plans = {}
+        @id = 0
       end
 
       def module_file_id(file)
@@ -257,58 +257,49 @@ module BoltSpec
       end
       # End apply_prep mocking
 
-      # Evaluates a `parallelize()` block and returns the result. Normally,
-      # Bolt's executor wraps this in a Yarn for each object passed to the
-      # `parallelize()` function, and then executes them in parallel before
-      # returning the result from the block. However, in BoltSpec the block is
-      # executed for each object sequentially, and this function returns the
-      # result itself.
-      #
-      def create_yarn(scope, block, object, _index)
-        # Create the new scope
-        newscope = Puppet::Parser::Scope.new(scope.compiler)
-        local = Puppet::Parser::Scope::LocalScope.new
-
-        # Compress the current scopes into a single vars hash to add to the new scope
-        current_scope = scope.effective_symtable(true)
-        until current_scope.nil?
-          current_scope.instance_variable_get(:@symbols)&.each_pair { |k, v| local[k] = v }
-          current_scope = current_scope.parent
-        end
-        newscope.push_ephemerals([local])
-
-        begin
-          result = catch(:return) do
-            args = { block.parameters[0][1].to_s => object }
-            block.closure.call_by_name_with_scope(newscope, args, true)
-          end
+      # Parallel function mocking
+      def run_in_thread
+        yield
+      end
 
-          # If we got a return from the block, get it's value
-          # Otherwise the result is the last line from the block
-          result = result.value if result.is_a?(Puppet::Pops::Evaluator::Return)
+      def in_parallel?
+        false
+      end
 
-          # 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
+      def create_future(scope: nil, name: nil)
+        newscope = nil
+        if scope
+          # Create the new scope
+          newscope = Puppet::Parser::Scope.new(scope.compiler)
+          local = Puppet::Parser::Scope::LocalScope.new
 
-          result
-        rescue Puppet::PreformattedError => e
-          if e.cause.is_a?(Bolt::Error)
-            e.cause
-          else
-            raise e
-          end
+          # Compress the current scopes into a single vars hash to add to the new scope
+          scope.to_hash(true, true).each_pair { |k, v| local[k] = v }
+          newscope.push_ephemerals([local])
         end
+
+        # Execute "futures" serially when running in BoltSpec
+        result = yield newscope
+        @id += 1
+        future = Bolt::PlanFuture.new(nil, @id, name: name)
+        future.value = result
+        future
       end
 
-      # BoltSpec already evaluated the `parallelize()` block for each object
-      # passed to the function, so these results can be returned as-is.
-      #
-      def round_robin(results)
+      def wait(results, **_kwargs)
         results
       end
 
+      # Since Futures are executed immediately once created, this will always
+      # be true by the time it's called.
+      def plan_complete?
+        true
+      end
+
+      def plan_futures
+        []
+      end
+
       # Public methods on Bolt::Executor that need to be mocked so there aren't
       # "undefined method" errors.
 
@@ -330,6 +321,8 @@ module BoltSpec
 
       def report_yaml_plan(_plan); end
 
+      def report_noop_mode(_mode); end
+
       def shutdown; end
 
       def start_plan(_plan_context); end
@@ -337,6 +330,8 @@ module BoltSpec
       def subscribe(_subscriber, _types = nil); end
 
       def unsubscribe(_subscriber, _types = nil); end
+
+      def round_robin; end
     end
   end
 end

data/lib/bolt_spec/run.rb

@@ -182,7 +182,10 @@ module BoltSpec
         @pal ||= Bolt::PAL.new(Bolt::Config::Modulepath.new(config.modulepath),
                                config.hiera_config,
                                config.project.resource_types,
-                               config.compile_concurrency)
+                               config.compile_concurrency,
+                               config.trusted_external,
+                               config.apply_settings,
+                               config.project)
       end
 
       def resolve_targets(target_spec)

data/modules/puppet_connect/plans/test_input_data.pp

@@ -1,8 +1,13 @@
 # @summary
 #   Tests that the provided Puppet Connect input data is complete, meaning that all consuming inventory targets are connectable.
-#
-# This plan should only be used as part of the copy-pastable "test input data"
-# workflow specified in the Puppet Connect docs.
+#   You should run this plan with the following command:
+#       PUPPET_CONNECT_INPUT_DATA=/path/to/input_data.yaml bolt plan run puppet_connect::test_input_data
+#   where /path/to/input_data.yaml is the path to the input_data.yaml file containing the key-value input for the
+#   puppet_connect_data plugin. If the plan fails on some targets, then you can use Bolt's --rerun option to rerun the plan on
+#   just the failed targets:
+#       PUPPET_CONNECT_INPUT_DATA=/path/to/input_data.yaml bolt plan run puppet_connect::test_input_data --rerun failure
+#   Note that this plan should only be used as part of the copy-pastable "test input data" workflow specified in the Puppet
+#   Connect docs.
 #
 # @param targets
 #   The set of targets to test. Usually this should be 'all', the default.

data/resources/bolt_bash_completion.sh

@@ -0,0 +1,214 @@
+#####################################################################
+###
+### Bash autocompletion for bolt
+### include this file in your .bash_profile or .bashrc to use completion
+### "source bolt_bash_completion.sh"
+###
+### Marc Schoechlin ms-github@256bit.org
+
+get_json_keys() {
+/opt/puppetlabs/bolt/bin/ruby <<-EOF
+  require 'json'
+  data = JSON.parse(File.read("${1}"))
+  puts data.keys.uniq.sort.join(' ')
+EOF
+}
+
+_bolt_complete() {
+  local prev
+  local cur
+  # Get the current word and previous word without colons
+  _get_comp_words_by_ref -n : cur
+  _get_comp_words_by_ref -n : prev
+
+  local next=""
+  local subcommand=${COMP_WORDS[1]}
+  [[ ${#COMP_WORDS[@]} -gt 2 ]] && local action=${COMP_WORDS[2]}
+  local context_opts="-m --modulepath --project"
+  local global_opts="--clear-cache -h --help --log-level --version"
+  local inventory_opts="-q --query --rerun -t --targets"
+  local authentication_opts="-u --user -p --password --password-prompt --private-key --host-key-check --no-host-key-check --ssl --no-ssl --ssl-verify --no-ssl-verify"
+  local escalation_opts="--run-as --sudo-password --sudo-password-prompt --sudo-executable"
+  local run_context_opts="-c --concurrency -i --inventoryfile --save-rerun --no-save-rerun --cleanup --no-cleanup"
+  local transport_opts="--transport --connect-timeout --tty --no-tty --native-ssh --no-native-ssh --ssh-command --copy-command"
+  local display_opts="--format --color --no-color -v --verbose --no-verbose --trace --stream"
+  local action_opts="${inventory_opts} ${context_opts} ${authentication_opts} ${escalation_opts} ${run_context_opts} ${transport_opts} ${display_opts}"
+  local apply_opts="--compile-concurrency --hiera-config"
+  local file_opts=" -m --modulepath --project --private-key -i --inventoryfile --hiera-config "
+
+  # If there's only one word and it's "bolt", tab complete the subcommand
+  if [ $COMP_CWORD -eq 1 ]; then
+    next="apply command file group guide inventory lookup module plan plugin project script secret task"
+  fi
+
+  # Tab complete files for options that accept files. The spaces are important!
+  # They make it so `bolt inventory` isn't confused with `--inventoryfile`.
+  if [[ $file_opts =~ " ${prev} " ]]; then
+    next=$(compgen -f -d "" -- $cur)
+  # Handle tab completing enumerable CLI options
+  elif [ "$prev" == "--log-level" ]; then
+    next="trace debug info warn error fatal any"
+  elif [ "$prev" == "--transport" ]; then
+    next="docker local lxd pcp podman remote ssh winrm"
+  elif [ "$prev" == "--format" ]; then
+    next="human json rainbow"
+  else
+    # Once we have subcommands, tab complete actions
+    case $subcommand in
+      apply)
+        next="${action_opts} ${apply_opts} -e --execute"
+        ;;
+      command)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="run"
+        elif [ $action = "run" ]; then
+          next="${action_opts} --env-var"
+        fi
+        ;;
+      file)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="download upload"
+        else
+          case $action in
+            download) next="${action_opts} --tmpdir";;
+            upload) next=$action_opts;;
+          esac
+        fi
+        ;;
+      group)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="show"
+        elif [ $action == 'show' ]; then
+          next="--project --format --inventoryfile"
+        fi
+        ;;
+      guide)
+        next="--format"
+        ;;
+      inventory)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="show"
+        elif [ $action == 'show' ]; then
+          next="${inventory_opts} --project --format --inventoryfile --detail"
+        fi
+        ;;
+      lookup)
+        next="${action_opts} --hiera-config --plan-hierarchy"
+        ;;
+      module)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="add generate-types install show"
+        else
+          case $action in
+            add | install) next="--project";;
+            generate-types) next="${context_opts}";;
+            show) next="${context_opts} --filter --format";;
+          esac
+        fi
+        ;;
+      plan)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="convert new run show"
+        elif [[ ($COMP_CWORD -eq 3 || \
+          ( $COMP_CWORD -eq 4 && "$cur" == *"::" ) || \
+          ( $COMP_CWORD -eq 5 && "$cur" == *"::"* )) &&
+          $action != "new" ]]; then
+
+          if [ -f "${PWD}/.plan_cache.json" ]; then
+            # Use Puppet's ruby instead of jq since we know it will be there.
+            next=$(get_json_keys "${PWD}/.plan_cache.json")
+          elif [ -f "${HOME}/.puppetlabs/bolt/.plan_cache.json" ]; then
+            next=$(get_json_keys "${HOME}/.puppetlabs/bolt/.plan_cache.json")
+          else
+            case $action in
+              convert) next="${context_opts}";;
+              new) next="--project --pp";;
+              run) next="${action_opts} ${apply_opts} --params --tmpdir";;
+              show) next="${context_opts} --filter --format";;
+            esac
+          fi
+        else
+          case $action in
+            convert) next="${context_opts}";;
+            new) next="--project --pp";;
+            run) next="${action_opts} ${apply_opts} --params --tmpdir";;
+            show) next="${context_opts} --filter --format";;
+          esac
+        fi
+        ;;
+      plugin)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="show"
+        else
+          next="${context_opts} --format --color --no-color"
+        fi
+        ;;
+      project)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="init migrate"
+        else
+          case $action in
+            init) next="--modules";;
+            migrate) next="--project --inventoryfile";;
+          esac
+        fi
+        ;;
+      script)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="run"
+        elif [[ $COMP_CWORD -eq 3 && $action == 'run' ]]; then
+          # List files and directories
+          next=$(compgen -f -d "" -- $cur)
+        elif [ $action == 'run' ]; then
+          next="${action_opts} --env-var --tmpdir"
+        fi
+        ;;
+      secret)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="createkeys encrypt decrypt"
+        else
+          case $action in
+            createkeys) next="${context_opts} --plugin --force";;
+            encrypt | decrypt) next="${context_opts} --plugin";;
+          esac
+        fi
+        ;;
+      task)
+        if [ $COMP_CWORD -eq 2 ]; then
+          next="run show"
+        elif [[ $COMP_CWORD -eq 3 || \
+          ( $COMP_CWORD -eq 4 && "$cur" == *"::" ) || \
+          ( $COMP_CWORD -eq 5 && "$cur" == *"::"* ) ]]; then
+          if [ -f "${PWD}/.task_cache.json" ]; then
+            # Use Puppet's ruby instead of jq since we know it will be there.
+            next=$(get_json_keys "${PWD}/.task_cache.json")
+          elif [ -f "${HOME}/.puppetlabs/bolt/.task_cache.json" ]; then
+            next=$(get_json_keys "${HOME}/.puppetlabs/bolt/.task_cache.json")
+          else
+            case $action in
+              run) next="${action_opts} --env-var --tmpdir";;
+              show) next="${context_opts} --filter --format";;
+            esac
+          fi
+        else
+          case $action in
+            run) next="${action_opts} --env-var --tmpdir";;
+            show) next="${context_opts} --filter --format";;
+          esac
+        fi
+        ;;
+    esac
+  fi
+
+  # If any of the next options are flags, we've reached the end of the
+  # building-a-Bolt-command part and can re-enable file and directory name
+  # completion and include Bolt's global flags.
+  if [[ "$next" =~ "--" ]]; then
+    next+=" ${global_opts}"
+  fi
+
+  COMPREPLY=($(compgen -W "$next" -- $cur))
+  __ltrim_colon_completions $cur
+}
+
+complete -F _bolt_complete bolt

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 3.8.1
+  version: 3.11.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-17 00:00:00.000000000 Z
+date: 2021-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -399,6 +399,7 @@ files:
 - Puppetfile
 - bolt-modules/boltlib/lib/puppet/datatypes/applyresult.rb
 - bolt-modules/boltlib/lib/puppet/datatypes/containerresult.rb
+- bolt-modules/boltlib/lib/puppet/datatypes/future.rb
 - bolt-modules/boltlib/lib/puppet/datatypes/resourceinstance.rb
 - bolt-modules/boltlib/lib/puppet/datatypes/result.rb
 - bolt-modules/boltlib/lib/puppet/datatypes/resultset.rb
@@ -406,6 +407,7 @@ files:
 - bolt-modules/boltlib/lib/puppet/functions/add_facts.rb
 - bolt-modules/boltlib/lib/puppet/functions/add_to_group.rb
 - bolt-modules/boltlib/lib/puppet/functions/apply_prep.rb
+- bolt-modules/boltlib/lib/puppet/functions/background.rb
 - bolt-modules/boltlib/lib/puppet/functions/catch_errors.rb
 - bolt-modules/boltlib/lib/puppet/functions/download_file.rb
 - bolt-modules/boltlib/lib/puppet/functions/facts.rb
@@ -432,6 +434,7 @@ files:
 - bolt-modules/boltlib/lib/puppet/functions/set_var.rb
 - bolt-modules/boltlib/lib/puppet/functions/upload_file.rb
 - bolt-modules/boltlib/lib/puppet/functions/vars.rb
+- bolt-modules/boltlib/lib/puppet/functions/wait.rb
 - bolt-modules/boltlib/lib/puppet/functions/wait_until_available.rb
 - bolt-modules/boltlib/lib/puppet/functions/without_default_logging.rb
 - bolt-modules/boltlib/lib/puppet/functions/write_file.rb
@@ -450,6 +453,7 @@ files:
 - bolt-modules/prompt/lib/puppet/functions/prompt/menu.rb
 - bolt-modules/system/lib/puppet/functions/system/env.rb
 - exe/bolt
+- guides/debugging.txt
 - guides/guide.txt
 - guides/inventory.txt
 - guides/links.txt
@@ -485,6 +489,7 @@ files:
 - lib/bolt/container_result.rb
 - lib/bolt/error.rb
 - lib/bolt/executor.rb
+- lib/bolt/fiber_executor.rb
 - lib/bolt/inventory.rb
 - lib/bolt/inventory/group.rb
 - lib/bolt/inventory/inventory.rb
@@ -528,6 +533,7 @@ files:
 - lib/bolt/pal/yaml_plan/step/upload.rb
 - lib/bolt/pal/yaml_plan/transpiler.rb
 - lib/bolt/plan_creator.rb
+- lib/bolt/plan_future.rb
 - lib/bolt/plan_result.rb
 - lib/bolt/plugin.rb
 - lib/bolt/plugin/cache.rb
@@ -583,13 +589,13 @@ files:
 - lib/bolt/util/puppet_log_level.rb
 - lib/bolt/validator.rb
 - lib/bolt/version.rb
-- lib/bolt/yarn.rb
 - lib/bolt_server/acl.rb
 - lib/bolt_server/base_config.rb
 - lib/bolt_server/config.rb
 - lib/bolt_server/file_cache.rb
 - lib/bolt_server/plugin.rb
 - lib/bolt_server/plugin/puppet_connect_data.rb
+- lib/bolt_server/request_error.rb
 - lib/bolt_server/schemas/action-check_node_connections.json
 - lib/bolt_server/schemas/action-run_command.json
 - lib/bolt_server/schemas/action-run_script.json
@@ -631,6 +637,7 @@ files:
 - modules/canary/plans/init.pp
 - modules/puppet_connect/plans/test_input_data.pp
 - modules/puppetdb_fact/plans/init.pp
+- resources/bolt_bash_completion.sh
 homepage: https://github.com/puppetlabs/bolt
 licenses:
 - Apache-2.0