bolt 3.7.1 → 3.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 741f798df2b4c7a46e45c5c87a41cd4e994506cdd202d26b6acafae7774135f8
-  data.tar.gz: 803789a5f6872e27656a733e94998acc9dde4d325d2d920b345a1c2848683f2f
+  metadata.gz: b54ca78ebd584ad7e8bd223f086ac1dfc86f6f8bca3e7a7a2aab93a466eebc44
+  data.tar.gz: f68a3dfe2dad3a15bd9d970860ad629de9fac40882291d6cd7b677bf0da5814e
 SHA512:
-  metadata.gz: 85cb83b0a0bf02d1ba15b14ba5e5e75c6ff290e1acee71b0de06ea716f3698e91358aa6f9961757b088afa3c98d519ba10f79a6195c767492a87603759c2fc81
-  data.tar.gz: 8180f0827c3576e676e6fca59af7744d3e375023b44c0ebc2e691801a25f8fc1cac2487276661f7b40503e8ab1164ae07ee5f8343be9bb5be3088851e81eafaf
+  metadata.gz: 879279d0db3506639ed99118623e90435e4f3ee70239aebd43e50d0fb8527eebf1ecfcf4298b6b110fcd34b560f4037cfc44439b2ad9858f67d9dfa1e5ad27e6
+  data.tar.gz: 36f05f2209c085c607200a857c380114eac7c631a6dd2b98550d27ece0488f3d0c3883693f83c74c3e87387a81e63d446727931084e40d27e6443a9c05eb1c4a

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/datatypes/future.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# The [`background()` plan function](plan_functions.md#background) returns a
+# `Future` object, which can be passed to the [`wait()` plan
+# function](plan_functions.md#wait) to block on the result of the backgrounded
+# code block.
+#
+# @!method state
+#   Either 'running' if the Future is still executing, 'done' if the Future
+#   finished successfully, or 'error' if the Future finished with an error.
+#
+Puppet::DataTypes.create_type('Future') do
+  interface <<-PUPPET
+    attributes => {},
+    functions => {
+      state => Callable[[], Enum['running', 'done', 'error']],
+    }
+  PUPPET
+
+  load_file('bolt/plan_future')
+
+  # Needed for Puppet to recognize Bolt::Result as a Puppet object when deserializing
+  Bolt::PlanFuture.include(Puppet::Pops::Types::PuppetObject)
+  implementation_class Bolt::PlanFuture
+end

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

@@ -16,6 +16,7 @@ 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 [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 [nil]
   # @example Prepare targets by name.
   #   apply_prep('target1,target2')
@@ -71,7 +72,8 @@ Puppet::Functions.create_function(:apply_prep) do
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'apply_prep')
     end
 
-    options = options.transform_keys { |k| k.sub(/^_/, '').to_sym }
+    # Unfreeze this
+    options = options.slice(*%w[_run_as _required_modules])
 
     applicator = Puppet.lookup(:apply_executor)
 
@@ -79,14 +81,14 @@ Puppet::Functions.create_function(:apply_prep) do
 
     targets = inventory.get_targets(target_spec)
 
-    required_modules = options[:required_modules].nil? ? nil : Array(options[:required_modules])
-    if required_modules&.any?
+    required_modules = options.delete('_required_modules').to_a
+    if required_modules.any?
       Puppet.debug("Syncing only required modules: #{required_modules.join(',')}.")
     end
 
     # Gather facts, including custom facts
     plugins = applicator.build_plugin_tarball do |mod|
-      next unless required_modules.nil? || required_modules.include?(mod.name)
+      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?
@@ -107,8 +109,9 @@ Puppet::Functions.create_function(:apply_prep) do
             opts = t.plugin_hooks&.fetch('puppet_library').dup
             plugin_name = opts.delete('plugin')
             hook = inventory.plugins.get_hook(plugin_name, :puppet_library)
+            # Give plan function options precedence over inventory options
             { 'target' => t,
-              'hook_proc' => hook.call(opts, t, self) }
+              'hook_proc' => hook.call(opts.merge(options), t, self) }
           rescue StandardError => e
             Bolt::Result.from_exception(t, e)
           end
@@ -132,7 +135,7 @@ Puppet::Functions.create_function(:apply_prep) do
 
         task = applicator.custom_facts_task
         arguments = { 'plugins' => Puppet::Pops::Types::PSensitiveType::Sensitive.new(plugins) }
-        results = executor.run_task(targets, task, arguments)
+        results = run_task(targets, task, arguments, options)
 
         # TODO: Standardize RunFailure type with error above
         raise Bolt::RunFailure.new(results, 'run_task', task.name) unless results.ok?

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

@@ -0,0 +1,61 @@
+# 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)
+
+    executor.create_future(scope: scope, name: name) 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/download_file.rb

@@ -112,17 +112,13 @@ Puppet::Functions.create_function(:download_file, Puppet::Functions::InternalFun
       call_function('debug', "Simulating file download of '#{source}' - no targets given - no action taken")
       Bolt::ResultSet.new([])
     else
-      r = if executor.in_parallel
-            require 'concurrent'
-            require 'fiber'
-            future = Concurrent::Future.execute do
-              executor.download_file(targets, source, destination, options, Puppet::Pops::PuppetStack.top_of_stack)
+      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
-
-            Fiber.yield('unfinished') while future.incomplete?
-            future.value || future.reason
           else
-            executor.download_file(targets, source, destination, options, Puppet::Pops::PuppetStack.top_of_stack)
+            executor.download_file(targets, source, destination, options, file_line)
           end
 
       if !r.ok && !options[:catch_errors]

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'bolt/yarn'
-
 # Map a code block onto an array, where each array element executes in parallel.
 # This function is experimental.
 #
@@ -35,21 +33,38 @@ Puppet::Functions.create_function(:parallelize, Puppet::Functions::InternalFunct
     executor = Puppet.lookup(:bolt_executor)
     executor.report_function_call(self.class.name)
 
-    skein = data.each_with_index.map do |object, index|
-      executor.create_yarn(scope, block, object, index)
-    end
+    futures = data.map do |object|
+      executor.create_future(scope: scope) do |newscope|
+        # Catch 'return' calls inside the block
+        result = catch(:return) do
+          # Add the object to the block parameters
+          args = { block.parameters[0][1].to_s => object }
+          # 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, args, true)
+        end
 
-    result = executor.round_robin(skein)
+        # 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)
 
-    failed_indices = result.each_index.select do |i|
-      result[i].is_a?(Bolt::Error)
-    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
 
-    # TODO: Inner catch errors block?
-    if failed_indices.any?
-      raise Bolt::ParallelFailure.new(result, failed_indices)
+        result
+      rescue Puppet::PreformattedError => e
+        if e.cause.is_a?(Bolt::Error)
+          e.cause
+        else
+          raise e
+        end
+      end
     end
 
-    result
+    # We may eventually want parallelize to accept a timeout
+    executor.wait(futures)
   end
 end

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

@@ -87,23 +87,13 @@ Puppet::Functions.create_function(:run_command) do
       call_function('debug', "Simulating run_command('#{command}') - no targets given - no action taken")
       Bolt::ResultSet.new([])
     else
-      r = if executor.in_parallel
-            require 'concurrent'
-            require 'fiber'
-            future = Concurrent::Future.execute do
-              executor.run_command(targets,
-                                   command,
-                                   options,
-                                   Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      r = if executor.in_parallel?
+            executor.run_in_thread do
+              executor.run_command(targets, command, options, file_line)
             end
-
-            Fiber.yield('unfinished') while future.incomplete?
-            future.value || future.reason
           else
-            executor.run_command(targets,
-                                 command,
-                                 options,
-                                 Puppet::Pops::PuppetStack.top_of_stack)
+            executor.run_command(targets, command, options, file_line)
           end
 
       if !r.ok && !options[:catch_errors]

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
@@ -126,25 +130,13 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      r = if executor.in_parallel
-            require 'concurrent'
-            require 'fiber'
-            future = Concurrent::Future.execute do
-              executor.run_script(targets,
-                                  found,
-                                  arguments,
-                                  options,
-                                  Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      r = if executor.in_parallel?
+            executor.run_in_thread do
+              executor.run_script(targets, found, arguments, options, file_line)
             end
-
-            Fiber.yield('unfinished') while future.incomplete?
-            future.value || future.reason
           else
-            executor.run_script(targets,
-                                found,
-                                arguments,
-                                options,
-                                Puppet::Pops::PuppetStack.top_of_stack)
+            executor.run_script(targets, found, arguments, options, file_line)
           end
 
       if !r.ok && !options[:catch_errors]

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

@@ -130,28 +130,19 @@ Puppet::Functions.create_function(:run_task) do
       end
     end
 
+    # Report whether the task was run in noop mode.
+    executor.report_noop_mode(executor.noop || options[:noop])
+
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      result = if executor.in_parallel
-                 require 'concurrent'
-                 require 'fiber'
-                 future = Concurrent::Future.execute do
-                   executor.run_task(targets,
-                                     task,
-                                     params,
-                                     options,
-                                     Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      result = if executor.in_parallel?
+                 executor.run_in_thread do
+                   executor.run_task(targets, task, params, options, file_line)
                  end
-
-                 Fiber.yield('unfinished') while future.incomplete?
-                 future.value || future.reason
                else
-                 executor.run_task(targets,
-                                   task,
-                                   params,
-                                   options,
-                                   Puppet::Pops::PuppetStack.top_of_stack)
+                 executor.run_task(targets, task, params, options, file_line)
                end
 
       if !result.ok && !options[:catch_errors]

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

@@ -175,28 +175,21 @@ Puppet::Functions.create_function(:run_task_with) do
       end
     end
 
+    # Report whether the task was run in noop mode.
+    executor.report_noop_mode(executor.noop || options[:noop])
+
     if targets.empty?
       Bolt::ResultSet.new([])
     else
       # Combine the results from the task run with any failing results that were
       # generated earlier when creating the target mapping
-      task_result = if executor.in_parallel
-                      require 'concurrent'
-                      require 'fiber'
-                      future = Concurrent::Future.execute do
-                        executor.run_task_with(target_mapping,
-                                               task,
-                                               options,
-                                               Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      task_result = if executor.in_parallel?
+                      executor.run_in_thread do
+                        executor.run_task_with(target_mapping, task, options, file_line)
                       end
-
-                      Fiber.yield('unfinished') while future.incomplete?
-                      future.value || future.reason
                     else
-                      executor.run_task_with(target_mapping,
-                                             task,
-                                             options,
-                                             Puppet::Pops::PuppetStack.top_of_stack)
+                      executor.run_task_with(target_mapping, task, options, file_line)
                     end
       result = Bolt::ResultSet.new(task_result.results + error_set)
 

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
@@ -83,25 +87,13 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
       call_function('debug', "Simulating file upload of '#{found}' - no targets given - no action taken")
       Bolt::ResultSet.new([])
     else
-      r = if executor.in_parallel
-            require 'concurrent'
-            require 'fiber'
-            future = Concurrent::Future.execute do
-              executor.upload_file(targets,
-                                   found,
-                                   destination,
-                                   options,
-                                   Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      r = if executor.in_parallel?
+            executor.run_in_thread do
+              executor.upload_file(targets, found, destination, options, file_line)
             end
-
-            Fiber.yield('unfinished') while future.incomplete?
-            future.value || future.reason
           else
-            executor.upload_file(targets,
-                                 found,
-                                 destination,
-                                 options,
-                                 Puppet::Pops::PuppetStack.top_of_stack)
+            executor.upload_file(targets, found, destination, options, file_line)
           end
       if !r.ok && !options[:catch_errors]
         raise Bolt::RunFailure.new(r, 'upload_file', source)