bolt 0.17.2 → 0.18.0

data/lib/bolt/inventory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require 'bolt/util'
 require 'bolt/target'
@@ -5,7 +7,7 @@ require 'bolt/inventory/group'
 
 module Bolt
   class Inventory
-    ENVIRONMENT_VAR = 'BOLT_INVENTORY'.freeze
+    ENVIRONMENT_VAR = 'BOLT_INVENTORY'
 
     class ValidationError < Bolt::Error
       attr_accessor :path
@@ -41,11 +43,7 @@ module Bolt
     def self.from_config(config)
       if ENV.include?(ENVIRONMENT_VAR)
         begin
-          # rubocop:disable YAMLLoad
-          data = YAML.load(ENV[ENVIRONMENT_VAR])
-        # In older releases of psych SyntaxError is not a subclass of Exception
-        rescue Psych::SyntaxError
-          raise Bolt::CLIError, "Could not parse inventory from $#{ENVIRONMENT_VAR}"
+          data = YAML.safe_load(ENV[ENVIRONMENT_VAR])
         rescue Psych::Exception
           raise Bolt::CLIError, "Could not parse inventory from $#{ENVIRONMENT_VAR}"
         end
@@ -56,7 +54,6 @@ module Bolt
       inventory = new(data, config)
       inventory.validate
       inventory.collect_groups
-      inventory.add_localhost
       inventory
     end
 
@@ -68,6 +65,7 @@ module Bolt
       @groups = Group.new(data.merge('name' => 'all'))
       @group_lookup = {}
       @target_vars = {}
+      @target_facts = {}
     end
 
     def validate
@@ -79,16 +77,6 @@ module Bolt
       @group_lookup = @groups.collect_groups
     end
 
-    def add_localhost
-      # Append a 'localhost' group if not already present.
-      unless @group_lookup.include?('localhost') || @groups.node_names.include?('localhost')
-        @groups.nodes['localhost'] = {
-          'name' => 'localhost',
-          'config' => { 'transport' => 'local' }
-        }
-      end
-    end
-
     def get_targets(targets)
       targets = expand_targets(targets)
       targets = if targets.is_a? Array
@@ -108,6 +96,15 @@ module Bolt
       @target_vars[target.name]
     end
 
+    def add_facts(target, new_facts = {})
+      @logger.warn("No facts to add") if new_facts.empty?
+      set_facts(target.name, new_facts)
+    end
+
+    def facts(target)
+      @target_facts[target.name]
+    end
+
     #### PRIVATE ####
     #
     # For debugging only now
@@ -119,19 +116,22 @@ module Bolt
     # Pass a target to get_targets for a public version of this
     # Should this reconfigure configured targets?
     def update_target(target)
-      data = @groups.data_for(target.name) || {}
+      data = @groups.data_for(target.name)
 
-      unless data['config']
-        @logger.debug("Did not find #{target.name} in inventory")
-        data['config'] = {}
+      unless data
+        data = {}
+        data['config'] = { 'transport' => 'local' } if target.name == 'localhost'
       end
 
-      unless data['vars']
-        @logger.debug("Did not find any variables for #{target.name} in inventory")
-        data['vars'] = {}
+      unless data['config']
+        @logger.debug("Did not find config for #{target.name} in inventory")
+        data['config'] = {}
       end
 
-      set_vars_from_hash(target.name, data['vars'])
+      # These should only get set from the inventory if they have not yet
+      # been instantiated
+      set_vars_from_hash(target.name, data['vars']) unless @target_vars[target.name]
+      set_facts(target.name, data['facts']) unless @target_facts[target.name]
 
       # Use Config object to ensure config section is treated consistently with config file
       conf = @config.deep_clone
@@ -183,15 +183,23 @@ module Bolt
     end
     private :expand_targets
 
-    def set_vars_from_hash(target_name, data)
+    def set_vars_from_hash(tname, data)
       if data
         # Instantiate empty vars hash in case no vars are defined
-        @target_vars[target_name] = @target_vars[target_name] || {}
+        @target_vars[tname] ||= {}
         # Assign target new merged vars hash
         # This is essentially a copy-on-write to maintain the immutability of @target_vars
-        @target_vars[target_name] = @target_vars[target_name].merge(data).freeze
+        @target_vars[tname] = @target_vars[tname].merge(data).freeze
       end
     end
     private :set_vars_from_hash
+
+    def set_facts(tname, hash)
+      if hash
+        @target_facts[tname] ||= {}
+        @target_facts[tname] = Bolt::Util.deep_merge(@target_facts[tname], hash).freeze
+      end
+    end
+    private :set_facts
   end
 end

data/lib/bolt/inventory/group.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bolt
   class Inventory
     # Group is a specific implementation of Inventory based on nested
@@ -10,18 +12,17 @@ module Bolt
         @name = data['name']
         @nodes = {}
 
-        if data['nodes']
-          data['nodes'].each do |n|
-            n = { 'name' => n } if n.is_a? String
-            if @nodes.include? n['name']
-              @logger.warn("Ignoring duplicate node in #{@name}: #{n}")
-            else
-              @nodes[n['name']] = n
-            end
+        data['nodes']&.each do |n|
+          n = { 'name' => n } if n.is_a? String
+          if @nodes.include? n['name']
+            @logger.warn("Ignoring duplicate node in #{@name}: #{n}")
+          else
+            @nodes[n['name']] = n
           end
         end
 
         @vars = data['vars'] || {}
+        @facts = data['facts'] || {}
         @config = data['config'] || {}
         @groups = if data['groups']
                     data['groups'].map { |g| Group.new(g) }
@@ -89,8 +90,7 @@ module Bolt
       end
 
       # The data functions below expect and return nil or a hash of the schema
-      # { 'config' => Hash , 'vars' => Hash, groups => Array }
-      # As we add more options beyond config this schema will grow
+      # { 'config' => Hash , 'vars' => Hash, 'facts' => Hash, groups => Array }
       def data_for(node_name)
         data_merge(group_collect(node_name), node_collect(node_name))
       end
@@ -99,6 +99,7 @@ module Bolt
         if (data = @nodes[node_name])
           { 'config' => data['config'] || {},
             'vars' => data['vars'] || {},
+            'facts' => data['facts'] || {},
             # groups come from group_data
             'groups' => [] }
         end
@@ -107,12 +108,14 @@ module Bolt
       def group_data
         { 'config' => @config,
           'vars'   => @vars,
+          'facts'  => @facts,
           'groups' => [@name] }
       end
 
       def empty_data
         { 'config' => {},
           'vars'   => {},
+          'facts'  => {},
           'groups' => [] }
       end
 
@@ -127,6 +130,7 @@ module Bolt
           # are assigned a new hash, rather than merging the existing value
           # with the value meant to replace it
           'vars'   => data2['vars'].merge(data1['vars']),
+          'facts'  => Bolt::Util.deep_merge(data1['facts'], data2['facts']),
           'groups' => data2['groups'] + data1['groups']
         }
       end

data/lib/bolt/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logging'
 
 module Bolt

data/lib/bolt/node/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bolt
   class Node
     class BaseError < Bolt::Error

data/lib/bolt/node/output.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'bolt/result'
 

data/lib/bolt/notifier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'concurrent'
 
 module Bolt

data/lib/bolt/outputter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bolt
   class Outputter
     def self.for_format(format)

data/lib/bolt/outputter/human.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'terminal-table'
 module Bolt
   class Outputter
@@ -74,25 +76,25 @@ module Bolt
       def print_summary(results, elapsed_time)
         ok_set = results.ok_set
         unless ok_set.empty?
-          @stream.puts format('Successful on %d node%s: %s',
-                              ok_set.size,
-                              ok_set.size == 1 ? '' : 's',
-                              ok_set.names.join(','))
+          @stream.puts format('Successful on %<size>d node%<plural>s: %<names>s',
+                              size: ok_set.size,
+                              plural: ok_set.size == 1 ? '' : 's',
+                              names: ok_set.names.join(','))
         end
 
         error_set = results.error_set
         unless error_set.empty?
           @stream.puts colorize(:red,
-                                format('Failed on %d node%s: %s',
-                                       error_set.size,
-                                       error_set.size == 1 ? '' : 's',
-                                       error_set.names.join(',')))
+                                format('Failed on %<size>d node%<plural>s: %<names>s',
+                                       size: error_set.size,
+                                       plural: error_set.size == 1 ? '' : 's',
+                                       names: error_set.names.join(',')))
         end
 
-        @stream.puts format('Ran on %d node%s in %.2f seconds',
-                            results.size,
-                            results.size == 1 ? '' : 's',
-                            elapsed_time)
+        @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)
       end
 
       def print_table(results)
@@ -113,9 +115,9 @@ module Bolt
       # @param [Hash] A hash representing the task
       def print_task_info(task)
         # Building lots of strings...
-        pretty_params = ""
-        task_info = ""
-        usage = "bolt task run --nodes, -n <node-name> #{task['name']}"
+        pretty_params = +""
+        task_info = +""
+        usage = +"bolt task run --nodes, -n <node-name> #{task['name']}"
 
         if task['parameters']
           replace_data_type(task['parameters'])
@@ -143,21 +145,13 @@ module Bolt
       # @param [Hash] A hash representing the plan
       def print_plan_info(plan)
         # Building lots of strings...
-        pretty_params = ""
-        plan_info = ""
-        usage = "bolt plan run #{plan['name']}"
-
-        if plan['parameters']
-          plan['parameters'].each do |p|
-            name = p['name']
-            pretty_params << "- #{name}: #{p['type']}\n"
-            usage << if p.include?('default_value')
-                       # TODO: print the default value when available
-                       " [#{name}=<value>]"
-                     else
-                       " #{name}=<value>"
-                     end
-          end
+        pretty_params = +""
+        plan_info = +""
+        usage = +"bolt plan run #{plan['name']}"
+
+        plan['parameters']&.each do |name, p|
+          pretty_params << "- #{name}: #{p['type']}\n"
+          usage << (p.include?('default_value') ? " [#{name}=<value>]" : " #{name}=<value>")
         end
 
         plan_info << "\n#{plan['name']}"
@@ -184,10 +178,10 @@ module Bolt
         end
       end
 
-      def fatal_error(e)
-        @stream.puts(colorize(:red, e.message))
-        if e.is_a? Bolt::RunFailure
-          @stream.puts ::JSON.pretty_generate(e.result_set)
+      def fatal_error(err)
+        @stream.puts(colorize(:red, err.message))
+        if err.is_a? Bolt::RunFailure
+          @stream.puts ::JSON.pretty_generate(err.result_set)
         end
       end
     end

data/lib/bolt/outputter/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bolt
   class Outputter
     class JSON < Bolt::Outputter
@@ -32,9 +34,9 @@ module Bolt
         @stream.puts "],\n"
         @preceding_item = false
         @items_open = false
-        @stream.puts format('"node_count": %d, "elapsed_time": %d }',
-                            results.size,
-                            elapsed_time)
+        @stream.puts format('"node_count": %<size>d, "elapsed_time": %<elapsed>d }',
+                            size: results.size,
+                            elapsed: elapsed_time)
       end
 
       def print_table(results)
@@ -55,10 +57,10 @@ module Bolt
         @stream.puts result.to_json
       end
 
-      def fatal_error(e)
+      def fatal_error(err)
         @stream.puts "],\n" if @items_open
         @stream.puts '"_error": ' if @object_open
-        @stream.puts e.to_json
+        @stream.puts err.to_json
         @stream.puts '}' if @object_open
       end
 

data/lib/bolt/pal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bolt/executor'
 require 'bolt/error'
 
@@ -46,6 +48,10 @@ module Bolt
           _pcore_init_hash.to_json(opts)
         end
       end
+
+      unless Puppet.settings.global_defaults_initialized?
+        Puppet.initialize_settings
+      end
     end
 
     # Create a top-level alias for TargetSpec so that users don't have to
@@ -63,18 +69,16 @@ module Bolt
     # Runs a block in a PAL script compiler configured for Bolt.  Catches
     # exceptions thrown by the block and re-raises them ensuring they are
     # Bolt::Errors since the script compiler block will squash all exceptions.
-    def in_bolt_compiler(opts = [])
-      Puppet.initialize_settings(opts)
+    def in_bolt_compiler
       r = Puppet::Pal.in_tmp_environment('bolt', modulepath: full_modulepath(@config[:modulepath]), facts: {}) do |pal|
         pal.with_script_compiler do |compiler|
           add_target_spec(compiler)
           begin
             yield compiler
           rescue Puppet::PreformattedError => err
-            # Puppet sometimes rescues exceptions notes the location and reraises
-            # For now return the original error. Exception cause support was added in Ruby 2.1
-            # so we fall back to reporting the error we got for Ruby 2.0.
-            if err.respond_to?(:cause) && err.cause
+            # Puppet sometimes rescues exceptions notes the location and reraises.
+            # Return the original error.
+            if err.cause
               if err.cause.is_a? Bolt::Error
                 err.cause
               else
@@ -107,8 +111,8 @@ module Bolt
 
     def in_plan_compiler(executor, inventory)
       with_bolt_executor(executor, inventory) do
-        with_puppet_settings do |opts|
-          in_bolt_compiler(opts) do |compiler|
+        with_puppet_settings do
+          in_bolt_compiler do |compiler|
             yield compiler
           end
         end
@@ -123,13 +127,16 @@ module Bolt
       end
     end
 
+    # TODO: PUP-8553 should replace this
     def with_puppet_settings
       Dir.mktmpdir('bolt') do |dir|
         cli = []
         Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
           cli << "--#{setting}" << dir
         end
-        yield cli
+        Puppet.settings.send(:clear_everything_for_tests)
+        Puppet.initialize_settings(cli)
+        yield
       end
     end
 
@@ -143,6 +150,37 @@ module Bolt
       end
     end
 
+    def parse_params(type, object_name, params)
+      in_bolt_compiler do |compiler|
+        if type == 'task'
+          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
+        end
+        param_spec ||= {}
+
+        params.each_with_object({}) do |(name, str), acc|
+          type = param_spec.dig(name, 'type')
+          begin
+            parsed = JSON.parse(str, quirks_mode: true)
+            # The type may not exist if the module is remote on orch or if a task
+            # defines no parameters. Since we treat no parameters as Any we
+            # should parse everything in this case
+            acc[name] = if type && !type.instance?(parsed)
+                          str
+                        else
+                          parsed
+                        end
+          rescue JSON::ParserError
+            # This value may not be assignable in which case run_* will error
+            acc[name] = str
+          end
+          acc
+        end
+      end
+    end
+
     def get_task_info(task_name)
       task = in_bolt_compiler do |compiler|
         compiler.task_signature(task_name)
@@ -161,6 +199,20 @@ module Bolt
       end
     end
 
+    # This coverts a plan signature object into a format approximating
+    # the task_hash of a task_signature
+    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 }
+        acc[param.name]['default_value'] = nil if param.key_type.is_a?(Puppet::Pops::Types::POptionalType)
+      end
+      {
+        'name' => plan_name,
+        'parameters' => parameters
+      }
+    end
+
     def get_plan_info(plan_name)
       plan = in_bolt_compiler do |compiler|
         compiler.plan_signature(plan_name)
@@ -169,34 +221,18 @@ module Bolt
       if plan.nil?
         raise Bolt::CLIError, Bolt::Error.unknown_plan(plan_name)
       end
-
-      elements = plan.params_type.elements
-      {
-        'name' => plan_name,
-        'parameters' =>
-          unless elements.nil? || elements.empty?
-            elements.map { |e|
-              p = {
-                'name' => e.name,
-                'type' => e.value_type
-              }
-              # TODO: when the default value can be obtained use the actual value instead of nil
-              p['default_value'] = nil if e.key_type.is_a?(Puppet::Pops::Types::POptionalType)
-              p
-            }
-          end
-      }
+      plan_hash(plan_name, plan)
     end
 
-    def run_task(object, targets, params, executor, inventory, &eventblock)
+    def run_task(task_name, targets, params, executor, inventory, &eventblock)
       in_task_compiler(executor, inventory) do |compiler|
-        compiler.call_function('run_task', object, targets, params, &eventblock)
+        compiler.call_function('run_task', task_name, targets, params, &eventblock)
       end
     end
 
-    def run_plan(object, params, executor = nil, inventory = nil)
+    def run_plan(plan_name, params, executor = nil, inventory = nil)
       in_plan_compiler(executor, inventory) do |compiler|
-        compiler.call_function('run_plan', object, params)
+        compiler.call_function('run_plan', plan_name, params)
       end
     end
   end