bolt 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c52a68237c35477a0e8a18b0ac4114476eaf6c49a21d454d7d2ae25031db44c
-  data.tar.gz: 73502d5faa64ef267863c436aea928af45991b8571a280f87f3fbcd888a2132c
+  metadata.gz: 4e5ae133bdd2f4e2a8d0c8b0660c0f80d3f4187efd005ccdeb02694775c9f8af
+  data.tar.gz: 870bb25eeaaefb615d637767909ff607550a12d572a8360ae9f8a386dd86d11e
 SHA512:
-  metadata.gz: d2bf04c7a4e6a5f72a7f92eb66f0937f5adb9767babf15639fbbe6f4b1b368996f2abeddfbc4a82e146124fce04282aecdf769a5475543b7b480e4fbf9865067
-  data.tar.gz: 96ace6cbf150ce44057a48f5e33571ebcc2255abecdf2ba70591b184776175ad8777a0dac6ffbef75740f60a84f92e205c3f915b5919d866b758bb64d0773523
+  metadata.gz: fb2090aac1cab95bbffa72ca1bb99af214ed910512e5fd19878b9d832518e2ee56df623c1ad74c41b160fc129bc7cf2904a876b267d2dfe8c2391fecdd941468
+  data.tar.gz: ff0d54e1b27bfcf35b3d78e6f4e9d95d5b470abf5aa2311acc85459a54bb9a8746a103633fb24bc55520406ac7eeba863ada6023185e6f0f8a9e1a36fe206b4e

data/bolt-modules/boltlib/lib/puppet/datatypes/applyresult.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+Puppet::DataTypes.create_type('ApplyResult') do
+  interface <<-PUPPET
+    attributes => {
+      'report' => Hash[String[1], Data],
+      'target' => Target
+    },
+    functions => {
+      error => Callable[[], Optional[Error]],
+      ok => Callable[[], Boolean],
+      message => Callable[[], Optional[String]],
+    }
+  PUPPET
+
+  load_file('bolt/apply_result')
+
+  implementation_class Bolt::ApplyResult
+end

data/bolt-modules/boltlib/lib/puppet/datatypes/resultset.rb

@@ -3,14 +3,14 @@
 Puppet::DataTypes.create_type('ResultSet') do
   interface <<-PUPPET
     attributes => {
-      'results' => Array[Result],
+      'results' => Array[Variant[Result, ApplyResult]],
     },
     functions => {
       count => Callable[[], Integer],
       empty => Callable[[], Boolean],
       error_set => Callable[[], ResultSet],
-      find => Callable[[String[1]], Optional[Result]],
-      first => Callable[[], Optional[Result]],
+      find => Callable[[String[1]], Optional[Variant[Result, ApplyResult]]],
+      first => Callable[[], Optional[Variant[Result, ApplyResult]]],
       names => Callable[[], Array[String[1]]],
       ok => Callable[[], Boolean],
       ok_set => Callable[[], ResultSet],

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

@@ -64,7 +64,8 @@ Puppet::Functions.create_function(:apply_prep) do
         end
 
         task = applicator.custom_facts_task
-        results = executor.run_task(targets, task, 'plugins' => plugins)
+        arguments = { 'plugins' => Puppet::Pops::Types::PSensitiveType::Sensitive.new(plugins) }
+        results = executor.run_task(targets, task, arguments)
         raise Bolt::RunFailure.new(results, 'run_task', task.name) unless results.ok?
 
         results.each do |result|

data/lib/bolt/analytics.rb

@@ -134,7 +134,6 @@ module Bolt
 
       def compute_os
         Concurrent::Future.execute(executor: @executor) do
-          require_relative '../../vendored/require_vendored'
           require 'facter'
           os = Facter.value('os')
           "#{os['name']} #{os.dig('release', 'major')}"

data/lib/bolt/applicator.rb

@@ -8,6 +8,7 @@ require 'logging'
 require 'minitar'
 require 'open3'
 require 'bolt/task'
+require 'bolt/apply_result'
 require 'bolt/util/puppet_log_level'
 
 module Bolt
@@ -113,56 +114,6 @@ module Bolt
       end
     end
 
-    def provide_puppet_missing_errors(result)
-      error_hash = result.error_hash
-      exit_code = error_hash['details']['exit_code'] if error_hash && error_hash['details']
-      # If we get exit code 126 or 127 back, it means the shebang command wasn't found; Puppet isn't present
-      if [126, 127].include?(exit_code)
-        Result.new(result.target, error:
-          {
-            'msg' => "Puppet is not installed on the target, please install it to enable 'apply'",
-            'kind' => 'bolt/apply-error'
-          })
-      elsif exit_code == 1 &&
-            (error_hash['msg'] =~ /Could not find executable 'ruby.exe'/ ||
-             error_hash['msg'] =~ /The term 'ruby.exe' is not recognized as the name of a cmdlet/)
-        # Windows does not have Ruby present
-        Result.new(result.target, error:
-          {
-            'msg' => "Puppet is not installed on the target in $env:ProgramFiles, please install it to enable 'apply'",
-            'kind' => 'bolt/apply-error'
-          })
-      elsif exit_code == 1 && error_hash['msg'] =~ /cannot load such file -- puppet \(LoadError\)/
-        # Windows uses a Ruby that doesn't have Puppet installed
-        # TODO: fix so we don't find other Rubies, or point to a known issues URL for more info
-        Result.new(result.target, error:
-          {
-            'msg' => 'Found a Ruby without Puppet present, please install Puppet ' \
-                     "or remove Ruby from $env:Path to enable 'apply'",
-            'kind' => 'bolt/apply-error'
-          })
-      else
-        result
-      end
-    end
-
-    def identify_resource_failures(result)
-      if result.ok? && result.value['status'] == 'failed'
-        resources = result.value['resource_statuses']
-        failed = resources.select { |_, r| r['failed'] }.flat_map do |key, resource|
-          resource['events'].select { |e| e['status'] == 'failure' }.map do |event|
-            "\n  #{key}: #{event['message']}"
-          end
-        end
-
-        result.value['_error'] = {
-          'msg' => "Resources failed to apply for #{result.target.name}#{failed.join}",
-          'kind' => 'bolt/resource-failure'
-        }
-      end
-      result
-    end
-
     def apply(args, apply_body, scope)
       raise(ArgumentError, 'apply requires a TargetSpec') if args.empty?
       type0 = Puppet.lookup(:pal_script_compiler).type('TargetSpec')
@@ -197,12 +148,14 @@ module Bolt
         result_promises = targets.zip(futures).flat_map do |target, future|
           @executor.queue_execute([target]) do |transport, batch|
             @executor.with_node_logging("Applying manifest block", batch) do
-              arguments = { 'catalog' => future.value, 'plugins' => plugins, '_noop' => options['_noop'] }
+              arguments = {
+                'catalog' => Puppet::Pops::Types::PSensitiveType::Sensitive.new(future.value),
+                'plugins' => Puppet::Pops::Types::PSensitiveType::Sensitive.new(plugins),
+                '_noop' => options['_noop']
+              }
               raise future.reason if future.rejected?
               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
+              Array(results).map { |result| ApplyResult.from_task_result(result) }
             end
           end
         end

data/lib/bolt/apply_result.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'bolt/error'
+require 'bolt/result'
+
+module Bolt
+  class ApplyResult < Result
+    def self.puppet_missing_error(result)
+      error_hash = result.error_hash
+      exit_code = error_hash['details']['exit_code'] if error_hash && error_hash['details']
+      # If we get exit code 126 or 127 back, it means the shebang command wasn't found; Puppet isn't present
+      if [126, 127].include?(exit_code)
+        {
+          'msg' => "Puppet is not installed on the target, please install it to enable 'apply'",
+          'kind' => 'bolt/apply-error'
+        }
+      elsif exit_code == 1 &&
+            (error_hash['msg'] =~ /Could not find executable 'ruby.exe'/ ||
+             error_hash['msg'] =~ /The term 'ruby.exe' is not recognized as the name of a cmdlet/)
+        # Windows does not have Ruby present
+        {
+          'msg' => "Puppet is not installed on the target in $env:ProgramFiles, please install it to enable 'apply'",
+          'kind' => 'bolt/apply-error'
+        }
+      elsif exit_code == 1 && error_hash['msg'] =~ /cannot load such file -- puppet \(LoadError\)/
+        # Windows uses a Ruby that doesn't have Puppet installed
+        # TODO: fix so we don't find other Rubies, or point to a known issues URL for more info
+        { 'msg' => 'Found a Ruby without Puppet present, please install Puppet ' \
+                   "or remove Ruby from $env:Path to enable 'apply'",
+          'kind' => 'bolt/apply-error' }
+      end
+    end
+
+    def self.resource_error(result)
+      if result.value['status'] == 'failed'
+        resources = result.value['resource_statuses']
+        failed = resources.select { |_, r| r['failed'] }.flat_map do |key, resource|
+          resource['events'].select { |e| e['status'] == 'failure' }.map do |event|
+            "\n  #{key}: #{event['message']}"
+          end
+        end
+
+        { 'msg' => "Resources failed to apply for #{result.target.name}#{failed.join}",
+          'kind' => 'bolt/resource-failure' }
+      end
+    end
+
+    def self.from_task_result(result)
+      if (puppet_missing = puppet_missing_error(result))
+        new(result.target,
+            error: puppet_missing,
+            report: result.value.reject { |k| k == '_error' })
+      elsif !result.ok?
+        new(result.target, error: result.error_hash)
+      elsif (resource_error = resource_error(result))
+        new(result.target,
+            error: resource_error,
+            report: result.value.reject { |k| k == '_error' })
+      else
+        new(result.target, report: result.value)
+      end
+    end
+
+    def initialize(target, error: nil, report: nil)
+      @target = target
+      @value = {}
+      value['report'] = report if report
+      value['_error'] = error if error
+      value['_output'] = metrics_message if metrics_message
+    end
+
+    def event_metrics
+      if (events = value.dig('report', 'metrics', 'resources', 'values'))
+        events.each_with_object({}) { |ev, h| h[ev[0]] = ev[2] }
+      end
+    end
+
+    # TODO: We've gotten requests for this type of logging but I'm not sure
+    # what we shold do with it exactly.
+    def log_events
+      logger = Logging.logger[target.name]
+      if (logs = value.dig('report', 'logs'))
+        logs.each do |log|
+          case log["level"]
+          when 'err'
+            logger.error(log['message'])
+          when 'warn'
+            logger.info(log['message'])
+          when 'notice'
+            logger.notice(log['message'])
+          when 'info'
+            logger.info(log['message'])
+          else
+            logger.debug(log["message"])
+          end
+        end
+      end
+    end
+
+    def metrics_message
+      if (metrics = event_metrics)
+        changed = metrics['changed']
+        failed = metrics['failed']
+        skipped = metrics['skipped']
+        unchanged = metrics['total'] - changed - failed - skipped
+        noop = metrics['out_of_sync'] - changed - failed
+        "changed: #{changed}, failed: #{failed}, unchanged: #{unchanged} skipped: #{skipped}, noop: #{noop}"
+      end
+    end
+
+    def report
+      @value['report']
+    end
+  end
+end

data/lib/bolt/outputter/human.rb

@@ -75,7 +75,7 @@ module Bolt
         end
       end
 
-      def print_summary(results, elapsed_time)
+      def print_summary(results, elapsed_time = nil)
         ok_set = results.ok_set
         unless ok_set.empty?
           @stream.puts format('Successful on %<size>d node%<plural>s: %<names>s',
@@ -93,10 +93,11 @@ module Bolt
                                        names: error_set.names.join(',')))
         end
 
-        @stream.puts format('Ran on %<size>d node%<plural>s in %<elapsed>.2f seconds',
-                            size: results.size,
-                            plural: results.size == 1 ? '' : 's',
-                            elapsed: elapsed_time)
+        total_msg = format('Ran on %<size>d node%<plural>s',
+                           size: results.size,
+                           plural: results.size == 1 ? '' : 's')
+        total_msg += format(' in %<elapsed>.2f seconds', elapsed: elapsed_time) unless elapsed_time.nil?
+        @stream.puts total_msg
       end
 
       def print_table(results)
@@ -178,10 +179,14 @@ module Bolt
 
       # @param [Bolt::PlanResult] plan_result A PlanResult object
       def print_plan_result(plan_result)
-        if plan_result.value.nil?
+        value = plan_result.value
+        if value.nil?
           @stream.puts("Plan completed successfully with no result")
-        elsif plan_result.value.is_a? Bolt::ApplyFailure
-          @stream.puts(colorize(:red, plan_result.value.message))
+        elsif value.is_a? Bolt::ApplyFailure
+          @stream.puts(colorize(:red, value.message))
+        elsif value.is_a? Bolt::ResultSet
+          value.each { |result| print_result(result) }
+          print_summary(value)
         else
           @stream.puts(::JSON.pretty_generate(plan_result, quirks_mode: true))
         end

data/lib/bolt/pal.rb

@@ -73,7 +73,6 @@ module Bolt
       end
 
       begin
-        require_relative '../../vendored/require_vendored'
         require 'puppet_pal'
       rescue LoadError
         raise Bolt::Error.new("Puppet must be installed to execute tasks", "bolt/puppet-missing")
@@ -241,7 +240,12 @@ module Bolt
     def plan_hash(plan_name, plan)
       elements = plan.params_type.elements || []
       parameters = elements.each_with_object({}) do |param, acc|
-        acc[param.name] = { 'type' => param.value_type }
+        type = if param.value_type.is_a?(Puppet::Pops::Types::PTypeAliasType)
+                 param.value_type.name
+               else
+                 param.value_type.to_s
+               end
+        acc[param.name] = { 'type' => type }
         acc[param.name]['default_value'] = nil if param.key_type.is_a?(Puppet::Pops::Types::POptionalType)
       end
       {

data/lib/bolt/transport/ssh.rb

@@ -55,7 +55,8 @@ module Bolt
           require 'net/ssh/krb'
         rescue LoadError
           logger.debug {
-            "Authentication method 'gssapi-with-mic' is not available"
+            "Authentication method 'gssapi-with-mic' is not available. "\
+            "Please install the kerberos gem with `gem install net-ssh-krb`"
           }
         end
 

data/lib/bolt/version.rb

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

data/lib/bolt_spec/run.rb

@@ -18,6 +18,7 @@ module BoltSpec
 
     def run_plan(plan_name, params = nil, config: nil, inventory: nil)
       # Users copying code from run_task may forget that targets is not a parameter for run plan
+      params ||= {}
       raise ArgumentError, "params must be a hash" unless params.is_a?(Hash)
 
       result = BoltRunner.with_runner(config, inventory) do |runner|

data/libexec/apply_catalog.rb

@@ -6,59 +6,50 @@ require 'json'
 require 'puppet'
 require 'puppet/configurer'
 require 'puppet/module_tool/tar'
+require 'securerandom'
 require 'tempfile'
 
 args = JSON.parse(ARGV[0] ? File.read(ARGV[0]) : STDIN.read)
 
-Puppet.initialize_settings([])
-run_mode = Puppet::Util::RunMode[:user]
-Puppet.settings.initialize_app_defaults(Puppet::Settings.app_defaults_for_run_mode(run_mode))
-
-Puppet::ApplicationSupport.push_application_context(run_mode)
+# Create temporary directories for all core Puppet settings so we don't clobber
+# existing state or read from puppet.conf. Also create a temporary modulepath.
+# Additionally include rundir, which gets its own initialization.
+puppet_root = Dir.mktmpdir
+moduledir = File.join(puppet_root, 'modules')
+Dir.mkdir(moduledir)
+cli = (Puppet::Settings::REQUIRED_APP_SETTINGS + [:rundir]).flat_map do |setting|
+  ["--#{setting}", File.join(puppet_root, setting.to_s.chomp('dir'))]
+end
+cli << '--modulepath' << moduledir
+Puppet.initialize_settings(cli)
 
 # Avoid extraneous output
-Puppet[:summarize] = false
-
-# Don't interfere with the normal agent
 Puppet[:report] = false
-Puppet[:graph] = false
-
-# Get a unique temporary path, but ensure the file doesn't exist or Puppet will report 'State got corrupted'
-statefile = Tempfile.new('puppet-state')
-Puppet[:statefile] = statefile.path
-statefile.close!
 
 # Make sure to apply the catalog
-Puppet[:use_cached_catalog] = false
 Puppet[:noop] = args['_noop'] || false
-Puppet[:strict_environment_mode] = false
-
-# The whole catalog
-Puppet[:tags] = nil
-Puppet[:skip_tags] = nil
-
-# And nothing but the catalog
-Puppet[:prerun_command] = nil
-Puppet[:postrun_command] = nil
 
 Puppet[:default_file_terminus] = :file_server
 
 exit_code = 0
-moduledir = Dir.mktmpdir
 begin
+  # This happens implicitly when running the Configurer, but we make it explicit here. It creates the
+  # directories we configured earlier.
+  Puppet.settings.use(:main)
+
   Tempfile.open('plugins.tar.gz') do |plugins|
     File.binwrite(plugins, Base64.decode64(args['plugins']))
     Puppet::ModuleTool::Tar.instance.unpack(plugins, moduledir, Etc.getlogin || Etc.getpwuid.name)
   end
 
-  env = Puppet.lookup(:environments).get('production').override_with(modulepath: [moduledir])
+  env = Puppet.lookup(:environments).get('production')
   # Needed to ensure features are loaded
   env.each_plugin_directory do |dir|
     $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
   end
 
   # Ensure custom facts are available for provider suitability tests
-  Puppet::Node::Facts.indirection.find('puppetversion', environment: env)
+  facts = Puppet::Node::Facts.indirection.find(SecureRandom.uuid, environment: env)
 
   report = if Puppet::Util::Package.versioncmp(Puppet.version, '5.0.0') > 0
              Puppet::Transaction::Report.new
@@ -67,11 +58,15 @@ begin
            end
 
   Puppet.override(current_environment: env,
-                  environments: Puppet::Environments::Static.new(env),
                   loaders: Puppet::Pops::Loaders.new(env)) do
-    catalog = Puppet::Resource::Catalog.from_data_hash(args['catalog']).to_ral
+    catalog = Puppet::Resource::Catalog.from_data_hash(args['catalog'])
     catalog.environment = env.name.to_s
     catalog.environment_instance = env
+    if defined?(Puppet::Pops::Evaluator::DeferredResolver)
+      # Only available in Puppet 6
+      Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(facts, catalog)
+    end
+    catalog = catalog.to_ral
 
     configurer = Puppet::Configurer.new
     configurer.run(catalog: catalog, report: report, pluginsync: false)
@@ -81,7 +76,7 @@ begin
   exit_code = report.exit_status != 1
 ensure
   begin
-    FileUtils.remove_dir(moduledir)
+    FileUtils.remove_dir(puppet_root)
   rescue Errno::ENOTEMPTY => e
     STDERR.puts("Could not cleanup temporary directory: #{e}")
   end