bolt 2.37.0 → 2.38.0

data/lib/bolt/module_installer/resolver.rb

@@ -9,7 +9,7 @@ module Bolt
     class Resolver
       # Resolves module specs and returns a Puppetfile object.
       #
-      def resolve(specs)
+      def resolve(specs, _config = {})
         require 'puppetfile-resolver'
 
         # Build the document model from the specs.

data/lib/bolt/outputter.rb

@@ -2,24 +2,25 @@
 
 module Bolt
   class Outputter
-    def self.for_format(format, color, verbose, trace)
+    def self.for_format(format, color, verbose, trace, spin)
       case format
       when 'human'
-        Bolt::Outputter::Human.new(color, verbose, trace)
+        Bolt::Outputter::Human.new(color, verbose, trace, spin)
       when 'json'
-        Bolt::Outputter::JSON.new(color, verbose, trace)
+        Bolt::Outputter::JSON.new(color, verbose, trace, false)
       when 'rainbow'
-        Bolt::Outputter::Rainbow.new(color, verbose, trace)
+        Bolt::Outputter::Rainbow.new(color, verbose, trace, spin)
       when nil
         raise "Cannot use outputter before parsing."
       end
     end
 
-    def initialize(color, verbose, trace, stream = $stdout)
+    def initialize(color, verbose, trace, spin, stream = $stdout)
       @color = color
       @verbose = verbose
       @trace = trace
       @stream = stream
+      @spin = spin
     end
 
     def indent(indent, string)
@@ -34,6 +35,19 @@ module Bolt
     def print_error
       raise NotImplementedError, "print_error() must be implemented by the outputter class"
     end
+
+    def start_spin; end
+
+    def stop_spin; end
+
+    def spin
+      start_spin
+      begin
+        yield
+      ensure
+        stop_spin
+      end
+    end
   end
 end
 

data/lib/bolt/outputter/human.rb

@@ -14,12 +14,13 @@ module Bolt
 
       def print_head; end
 
-      def initialize(color, verbose, trace, stream = $stdout)
+      def initialize(color, verbose, trace, spin, stream = $stdout)
         super
         # Plans and without_default_logging() calls can both be nested, so we
         # track each of them with a "stack" consisting of an integer.
         @plan_depth = 0
         @disable_depth = 0
+        @pinwheel = %w[- \\ | /]
       end
 
       def colorize(color, string)
@@ -30,6 +31,24 @@ module Bolt
         end
       end
 
+      def start_spin
+        return unless @spin
+        @spin = true
+        @spin_thread = Thread.new do
+          loop do
+            sleep(0.1)
+            @stream.print(colorize(:cyan, @pinwheel.rotate!.first + "\b"))
+          end
+        end
+      end
+
+      def stop_spin
+        return unless @spin
+        @spin_thread.terminate
+        @spin = false
+        @stream.print("\b")
+      end
+
       def remove_trail(string)
         string.sub(/\s\z/, '')
       end

data/lib/bolt/outputter/json.rb

@@ -3,7 +3,7 @@
 module Bolt
   class Outputter
     class JSON < Bolt::Outputter
-      def initialize(color, verbose, trace, stream = $stdout)
+      def initialize(color, verbose, trace, spin, stream = $stdout)
         super
         @items_open = false
         @object_open = false

data/lib/bolt/outputter/logger.rb

@@ -6,7 +6,7 @@ module Bolt
   class Outputter
     class Logger < Bolt::Outputter
       def initialize(verbose, trace)
-        super(false, verbose, trace)
+        super(false, verbose, trace, false)
         @logger = Bolt::Logger.logger(self)
       end
 

data/lib/bolt/outputter/rainbow.rb

@@ -5,7 +5,7 @@ require 'bolt/pal'
 module Bolt
   class Outputter
     class Rainbow < Bolt::Outputter::Human
-      def initialize(color, verbose, trace, stream = $stdout)
+      def initialize(color, verbose, trace, spin, stream = $stdout)
         begin
           require 'paint'
           if Bolt::Util.windows?
@@ -62,6 +62,17 @@ module Bolt
         end
       end
 
+      def start_spin
+        return unless @spin
+        @spin = true
+        @spin_thread = Thread.new do
+          loop do
+            @stream.print(colorize(:rainbow, @pinwheel.rotate!.first + "\b"))
+            sleep(0.1)
+          end
+        end
+      end
+
       def print_summary(results, elapsed_time = nil)
         ok_set = results.ok_set
         unless ok_set.empty?

data/lib/bolt/plugin/puppetdb.rb

@@ -12,7 +12,7 @@ module Bolt
       end
 
       TEMPLATE_OPTS = %w[alias config facts features name uri vars].freeze
-      PLUGIN_OPTS = %w[_plugin query target_mapping].freeze
+      PLUGIN_OPTS = %w[_plugin _cache query target_mapping].freeze
 
       attr_reader :puppetdb_client
 

data/lib/bolt/project.rb

@@ -2,7 +2,7 @@
 
 require 'pathname'
 require 'bolt/config'
-require 'bolt/config/validator'
+require 'bolt/validator'
 require 'bolt/pal'
 require 'bolt/module'
 
@@ -83,11 +83,7 @@ module Bolt
 
       logs << { info: "Loaded #{default}project from '#{fullpath}'" } if exist
 
-      # Validate the config against the schema. This will raise a single error
-      # with all validation errors.
-      schema = Bolt::Config::OPTIONS.slice(*Bolt::Config::BOLT_PROJECT_OPTIONS)
-
-      Bolt::Config::Validator.new.tap do |validator|
+      Bolt::Validator.new.tap do |validator|
         validator.validate(data, schema, project_file)
 
         validator.warnings.each { |warning| logs << { warn: warning } }
@@ -100,6 +96,16 @@ module Bolt
       new(data, path, type, logs, deprecations)
     end
 
+    # Builds the schema for bolt-project.yaml used by the validator.
+    #
+    def self.schema
+      {
+        type:        Hash,
+        properties:  Bolt::Config::BOLT_PROJECT_OPTIONS.map { |opt| [opt, _ref: opt] }.to_h,
+        definitions: Bolt::Config::OPTIONS
+      }
+    end
+
     def initialize(raw_data, path, type = 'option', logs = [], deprecations = [])
       @path         = Pathname.new(path).expand_path
       @project_file = @path + CONFIG_NAME
@@ -196,6 +202,10 @@ module Bolt
       @data['plugin-cache']
     end
 
+    def module_install
+      @data['module-install']
+    end
+
     def modules
       @modules ||= @data['modules']&.map do |mod|
         if mod.is_a?(String)
@@ -217,7 +227,10 @@ module Bolt
           raise Bolt::ValidationError, "The project '#{name}' will not be loaded. The project name conflicts "\
             "with a built-in Bolt module of the same name."
         end
-      else
+      elsif name.nil? &&
+            (File.directory?(plans_path) ||
+            File.directory?(@path + 'tasks') ||
+            File.directory?(@path + 'files'))
         message = "No project name is specified in bolt-project.yaml. Project-level content will not be available."
         @logs << { warn: message }
       end

data/lib/bolt/project_manager.rb

@@ -103,7 +103,9 @@ module Bolt
       # early here and not initialize the project if the modules cannot be
       # resolved and installed.
       if modules
+        @outputter.start_spin
         Bolt::ModuleInstaller.new(@outputter, @pal).install(modules, puppetfile, moduledir)
+        @outputter.stop_spin
       end
 
       data = { 'name' => project_name }

data/lib/bolt/project_manager/config_migrator.rb

@@ -72,7 +72,15 @@ module Bolt
         data     = Bolt::Util.read_yaml_hash(project_file, 'config')
         modified = false
 
-        [%w[apply_settings apply-settings], %w[plugin_hooks plugin-hooks]].each do |old, new|
+        # Keys to update. The first element is the old key, while the second is
+        # the key update it to.
+        to_update = [
+          %w[apply_settings apply-settings],
+          %w[puppetfile module-install],
+          %w[plugin_hooks plugin-hooks]
+        ]
+
+        to_update.each do |old, new|
           next unless data.key?(old)
 
           if data.key?(new)

data/lib/bolt/project_manager/module_migrator.rb

@@ -61,6 +61,7 @@ module Bolt
         # Create specs to resolve from
         specs = Bolt::ModuleInstaller::Specs.new(modules.map(&:to_hash))
 
+        @outputter.start_spin
         # Attempt to resolve dependencies
         begin
           @outputter.print_message('')
@@ -72,6 +73,7 @@ module Bolt
         end
 
         migrate_managed_modules(puppetfile, puppetfile_path, managed_moduledir)
+        @outputter.stop_spin
 
         # Move remaining modules to 'modules'
         consolidate_modules(modulepath)

data/lib/bolt/puppetdb/client.rb

@@ -18,6 +18,7 @@ module Bolt
       def query_certnames(query)
         return [] unless query
 
+        @logger.debug("Querying certnames")
         results = make_query(query)
 
         if results&.first && !results.first&.key?('certname')
@@ -34,6 +35,8 @@ module Bolt
         certnames.uniq!
         name_query = certnames.map { |c| ["=", "certname", c] }
         name_query.insert(0, "or")
+
+        @logger.debug("Querying certnames")
         result = make_query(name_query, 'inventory')
 
         result&.each_with_object({}) do |node, coll|
@@ -52,6 +55,8 @@ module Bolt
         facts_query.insert(0, "or")
 
         query = ['and', name_query, facts_query]
+
+        @logger.debug("Querying certnames")
         result = make_query(query, 'fact-contents')
         result.map! { |h| h.delete_if { |k, _v| %w[environment name].include?(k) } }
         result.group_by { |c| c['certname'] }
@@ -63,11 +68,13 @@ module Bolt
         url += "/#{path}" if path
 
         begin
+          @logger.debug("Sending PuppetDB query to #{url}")
           response = http_client.post(url, body: body, header: headers)
         rescue StandardError => e
           raise Bolt::PuppetDBFailoverError, "Failed to query PuppetDB: #{e}"
         end
 
+        @logger.debug("Got response code #{response.code} from PuppetDB")
         if response.code != 200
           msg = "Failed to query PuppetDB: #{response.body}"
           if response.code == 400
@@ -92,6 +99,7 @@ module Bolt
         return @http if @http
         # lazy-load expensive gem code
         require 'httpclient'
+        @logger.trace("Creating HTTP Client")
         @http = HTTPClient.new
         @http.ssl_config.set_client_cert_file(@config.cert, @config.key) if @config.cert
         @http.ssl_config.add_trust_ca(@config.cacert)

data/lib/bolt/shell/powershell.rb

@@ -193,7 +193,8 @@ module Bolt
       def run_command(command, options = {}, position = [])
         command = [*env_declarations(options[:env_vars]), command].join("\r\n") if options[:env_vars]
 
-        output = execute(command)
+        wrap_command = conn.is_a?(Bolt::Transport::Local::Connection)
+        output = execute(command, wrap_command)
         Bolt::Result.for_command(target,
                                  output.stdout.string,
                                  output.stderr.string,
@@ -284,8 +285,9 @@ module Bolt
         end
       end
 
-      def execute(command)
-        if conn.max_command_length && command.length > conn.max_command_length
+      def execute(command, wrap_command = false)
+        if (conn.max_command_length && command.length > conn.max_command_length) ||
+           wrap_command
           return with_tmpdir do |dir|
             command += "\r\nif (!$?) { if($LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 } }"
             script_file = File.join(dir, "#{SecureRandom.uuid}_wrapper.ps1")

data/lib/bolt/target.rb

@@ -80,6 +80,10 @@ module Bolt
       inventory_target.resources
     end
 
+    def set_local_defaults
+      inventory_target.set_local_defaults
+    end
+
     # rubocop:disable Naming/AccessorMethodName
     def set_resource(resource)
       inventory_target.set_resource(resource)

data/lib/bolt/transport/local.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'bolt/logger'
 require 'bolt/transport/simple'
 
 module Bolt
@@ -10,6 +11,18 @@ module Bolt
       end
 
       def with_connection(target)
+        if target.transport_config['bundled-ruby'] || target.name == 'localhost'
+          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/validator.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# This class validates config against a schema, raising an error that includes
+# details about any invalid configuration.
+#
+module Bolt
+  class Validator
+    attr_reader :deprecations, :warnings
+
+    def initialize
+      @errors       = []
+      @deprecations = []
+      @warnings     = []
+      @path         = []
+    end
+
+    # This is the entry method for validating data against the schema.
+    #
+    def validate(data, schema, location = nil)
+      @schema   = schema
+      @location = location
+
+      validate_value(data, schema)
+
+      raise_error
+    end
+
+    # Raises a ValidationError if there are any errors. All error messages
+    # created during validation are concatenated into a single error
+    # message.
+    #
+    private def raise_error
+      return unless @errors.any?
+
+      message = "Invalid configuration"
+      message += " at #{@location}" if @location
+      message += ":\n"
+      message += @errors.map { |error| "\s\s#{error}" }.join("\n")
+
+      raise Bolt::ValidationError, message
+    end
+
+    # Validate an individual value. This performs validation that is
+    # common to all values, including type validation. After validating
+    # the value's type, the value is passed off to an individual
+    # validation method for the value's type.
+    #
+    private def validate_value(value, definition)
+      definition = @schema.dig(:definitions, definition[:_ref]) if definition[:_ref]
+
+      return if plugin_reference?(value, definition)
+      return unless valid_type?(value, definition)
+
+      case value
+      when Hash
+        validate_hash(value, definition)
+      when Array
+        validate_array(value, definition)
+      when String
+        validate_string(value, definition)
+      when Numeric
+        validate_number(value, definition)
+      end
+    end
+
+    # Validates a hash value, logging errors for any validations that fail.
+    # This will enumerate each key-value pair in the hash and validate each
+    # value individually.
+    #
+    private def validate_hash(value, definition)
+      properties = definition[:properties] ? definition[:properties].keys : []
+
+      if definition[:properties] && definition[:additionalProperties].nil?
+        validate_keys(value.keys, properties)
+      end
+
+      if definition[:required] && (definition[:required] - value.keys).any?
+        missing = definition[:required] - value.keys
+        @errors << "Value at '#{path}' is missing required keys #{missing.join(', ')}"
+      end
+
+      value.each_pair do |key, val|
+        @path.push(key)
+
+        if properties.include?(key)
+          check_deprecated(key, definition[:properties][key])
+          validate_value(val, definition[:properties][key])
+        elsif definition[:additionalProperties]
+          validate_value(val, definition[:additionalProperties])
+        end
+      ensure
+        @path.pop
+      end
+    end
+
+    # Validates an array value, logging errors for any validations that fail.
+    # This will enumerate the items in the array and validate each item
+    # individually.
+    #
+    private def validate_array(value, definition)
+      if definition[:uniqueItems] && value.size != value.uniq.size
+        @errors << "Value at '#{path}' must not include duplicate elements"
+        return
+      end
+
+      return unless definition.key?(:items)
+
+      value.each_with_index do |item, index|
+        @path.push(index)
+        validate_value(item, definition[:items])
+      ensure
+        @path.pop
+      end
+    end
+
+    # Validates a string value, logging errors for any validations that fail.
+    #
+    private def validate_string(value, definition)
+      if definition.key?(:enum) && !definition[:enum].include?(value)
+        message  = "Value at '#{path}' must be "
+        message += "one of " if definition[:enum].count > 1
+        message += definition[:enum].join(', ')
+        multitype_error(message, value, definition)
+      end
+    end
+
+    # Validates a numeric value, logging errors for any validations that fail.
+    #
+    private def validate_number(value, definition)
+      if definition.key?(:minimum) && value < definition[:minimum]
+        @errors << "Value at '#{path}' must be a minimum of #{definition[:minimum]}"
+      end
+
+      if definition.key?(:maximum) && value > definition[:maximum]
+        @errors << "Value at '#{path}' must be a maximum of #{definition[:maximum]}"
+      end
+    end
+
+    # Adds warnings for unknown config options.
+    #
+    private def validate_keys(keys, known_keys)
+      (keys - known_keys).each do |key|
+        message  = "Unknown option '#{key}'"
+        message += " at '#{path}'" if @path.any?
+        message += " at #{@location}" if @location
+        message += "."
+        @warnings << message
+      end
+    end
+
+    # Adds a warning if the given option is deprecated.
+    #
+    private def check_deprecated(key, definition)
+      definition = @schema.dig(:definitions, definition[:_ref]) if definition[:_ref]
+
+      if definition.key?(:_deprecation)
+        message  = "Option '#{path}' "
+        message += "at #{@location} " if @location
+        message += "is deprecated. #{definition[:_deprecation]}"
+        @deprecations << { option: key, message: message }
+      end
+    end
+
+    # Returns true if a value is a plugin reference. This also validates whether
+    # a value can be a plugin reference in the first place. If the value is a
+    # plugin reference but cannot be one according to the schema, then this will
+    # log an error.
+    #
+    private def plugin_reference?(value, definition)
+      if value.is_a?(Hash) && value.key?('_plugin')
+        unless definition[:_plugin]
+          @errors << "Value at '#{path}' is a plugin reference, which is unsupported at "\
+                      "this location"
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    # Asserts the type for each option against the type specified in the schema
+    # definition. The schema definition can specify multiple valid types, so the
+    # value needs to only match one of the types to be valid. Returns early if
+    # there is no type in the definition (in practice this shouldn't happen, but
+    # this will safeguard against any dev mistakes).
+    #
+    private def valid_type?(value, definition)
+      return unless definition.key?(:type)
+
+      types = Array(definition[:type])
+
+      if types.include?(value.class)
+        true
+      else
+        if types.include?(TrueClass) || types.include?(FalseClass)
+          types = types - [TrueClass, FalseClass] + ['Boolean']
+        end
+
+        @errors << "Value at '#{path}' must be of type #{types.join(' or ')}"
+
+        false
+      end
+    end
+
+    # Adds an error that includes additional helpful information for values
+    # that accept multiple types.
+    #
+    private def multitype_error(message, value, definition)
+      if Array(definition[:type]).count > 1
+        types    = Array(definition[:type]) - [value.class]
+        message += " or must be of type #{types.join(' or ')}"
+      end
+
+      @errors << message
+    end
+
+    # Returns the formatted path for the key.
+    #
+    private def path
+      @path.join('.')
+    end
+  end
+end