bolt 2.37.0 → 2.38.0

data/lib/bolt/config/transport/base.rb

@@ -2,7 +2,7 @@
 
 require 'bolt/error'
 require 'bolt/util'
-require 'bolt/config/validator'
+require 'bolt/validator'
 require 'bolt/config/transport/options'
 
 module Bolt
@@ -125,7 +125,7 @@ module Bolt
 
         # Validation defaults to just asserting the option types
         private def validate
-          Bolt::Config::Validator.new.validate(@config.compact, self.class.schema.fetch(:properties))
+          Bolt::Validator.new.validate(@config.compact, self.class.schema)
         end
       end
     end

data/lib/bolt/config/transport/local.rb

@@ -8,6 +8,7 @@ module Bolt
     module Transport
       class Local < Base
         WINDOWS_OPTIONS = %w[
+          bundled-ruby
           cleanup
           interpreters
           tmpdir

data/lib/bolt/config/transport/options.rb

@@ -6,73 +6,8 @@ module Bolt
       module Options
         LOGIN_SHELLS = %w[sh bash zsh dash ksh powershell].freeze
 
-        # The following constants define the various configuration options available to Bolt's
-        # transports. Each constant is a hash where keys are the configuration option and values
-        # are the option's definition. These options are used in multiple locations:
-        #
-        #   - Automatic type validation when loading and setting configuration
-        #   - Generating reference documentation for configuration files
-        #   - Generating JSON schemas for configuration files
-        #
-        # Data includes keys defined by JSON Schema Draft 07 as well as some metadata used
-        # by Bolt to generate documentation. The following keys are used:
-        #
-        #   :description    String      A detailed description of the option and what it does. This
-        #                               field is used in both documentation and the JSON schemas,
-        #                               and should provide as much detail as possible, including
-        #                               links to relevant documentation.
-        #
-        #   :type           Class       The expected type of a value. These should be Ruby classes,
-        #                               as this field is used to perform automatic type validation.
-        #                               If an option can accept more than one type, this should be
-        #                               an array of types. Boolean values should set :type to
-        #                               [TrueClass, FalseClass], as Ruby does not have a single
-        #                               Boolean class.
-        #
-        #   :items          Hash        A definition hash for items in an array. Similar to values
-        #                               for top-level options, items can have a :description, :type,
-        #                               or any other key in this list.
-        #
-        #   :uniqueItems    Boolean     Whether or not an array should contain only unique items.
-        #
-        #   :properties     Hash        A hash where keys are sub-options and values are definitions
-        #                               for the sub-option. Similar to values for top-level options,
-        #                               properties can have a :description, :type, or any other key
-        #                               in this list.
-        #
-        #   :additionalProperties       A variation of the :properties key, where the hash is a
-        #                   Hash        definition for any properties not specified in :properties.
-        #                               This can be used to permit arbitrary sub-options, such as
-        #                               logs for the 'log' option.
-        #
-        #   :propertyNames  Hash        A hash that defines the properties that an option's property
-        #                               names must adhere to.
-        #
-        #   :required       Array       An array of properties that are required for options that
-        #                               accept Hash values.
-        #
-        #   :minimum        Integer     The minimum integer value for an option.
-        #
-        #   :enum           Array       An array of values that the option recognizes.
-        #
-        #   :pattern        String      A JSON regex pattern that the option's vaue should match.
-        #
-        #   :format         String      Requires that a string value matches a format defined by the
-        #                               JSON Schema draft.
-        #
-        #   :_plugin        Boolean     Whether the option accepts a plugin reference. This is used
-        #                               when generating the JSON schemas to determine whether or not
-        #                               to include a reference to the _plugin definition. If :_plugin
-        #                               is set to true, the script that generates JSON schemas will
-        #                               automatically recurse through the :items and :properties keys
-        #                               and add plugin references if applicable.
-        #
-        #   :_example       Any         An example value for the option. This is used to generate
-        #                               reference documentation for configuration files.
-        #
-        #   :_default       Any         The documented default value for the option. This is only
-        #                               used to generate reference documentation for configuration
-        #                               files and is not used by Bolt to actually set default values.
+        # Definitions used to validate config options.
+        # https://github.com/puppetlabs/bolt/blob/main/schemas/README.md
         TRANSPORT_OPTIONS = {
           "basic-auth-only" => {
             type: [TrueClass, FalseClass],
@@ -81,6 +16,13 @@ module Bolt
             _default: false,
             _example: true
           },
+          "bundled-ruby" => {
+            description: "Whether to use the Ruby bundled with Bolt packages for local targets.",
+            type: [TrueClass, FalseClass],
+            _plugin: false,
+            _example: true,
+            _default: false
+          },
           "cacert" => {
             type: String,
             description: "The path to the CA certificate.",

data/lib/bolt/inventory.rb

@@ -4,13 +4,17 @@ require 'set'
 require 'bolt/config'
 require 'bolt/inventory/group'
 require 'bolt/inventory/inventory'
+require 'bolt/inventory/options'
 require 'bolt/target'
 require 'bolt/util'
 require 'bolt/plugin'
+require 'bolt/validator'
 require 'yaml'
 
 module Bolt
   class Inventory
+    include Bolt::Inventory::Options
+
     ENVIRONMENT_VAR = 'BOLT_INVENTORY'
 
     class ValidationError < Bolt::Error
@@ -45,11 +49,25 @@ module Bolt
       end
     end
 
+    # Builds the schema used by the validator.
+    #
+    def self.schema
+      schema = {
+        type:        Hash,
+        properties:  OPTIONS.map { |opt| [opt, _ref: opt] }.to_h,
+        definitions: DEFINITIONS
+      }
+
+      schema[:definitions]['config'][:properties] = Bolt::Config.transport_definitions
+      schema
+    end
+
     def self.from_config(config, plugins)
       logger = Bolt::Logger.logger(self)
 
       if ENV.include?(ENVIRONMENT_VAR)
         begin
+          source = ENVIRONMENT_VAR
           data = YAML.safe_load(ENV[ENVIRONMENT_VAR])
           raise Bolt::ParseError, "Could not parse inventory from $#{ENVIRONMENT_VAR}" unless data.is_a?(Hash)
           logger.debug("Loaded inventory from environment variable #{ENVIRONMENT_VAR}")
@@ -57,9 +75,11 @@ module Bolt
           raise Bolt::ParseError, "Could not parse inventory from $#{ENVIRONMENT_VAR}"
         end
       elsif config.inventoryfile
+        source = config.inventoryfile
         data = Bolt::Util.read_yaml_hash(config.inventoryfile, 'inventory')
         logger.debug("Loaded inventory from #{config.inventoryfile}")
       else
+        source = config.default_inventoryfile
         data = Bolt::Util.read_optional_yaml_hash(config.default_inventoryfile, 'inventory')
 
         if config.default_inventoryfile.exist?
@@ -74,6 +94,11 @@ module Bolt
         t.resolve(plugins) unless t.resolved?
       end
 
+      Bolt::Validator.new.tap do |validator|
+        validator.validate(data, schema, source)
+        validator.warnings.each { |warning| logger.warn(warning) }
+      end
+
       inventory = create_version(data, config.transport, config.transports, plugins)
       inventory.validate
       inventory

data/lib/bolt/inventory/options.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'bolt/config/options'
+
+module Bolt
+  class Inventory
+    module Options
+      # Top-level options available in the inventory.
+      OPTIONS = %w[
+        config
+        facts
+        features
+        groups
+        targets
+        vars
+      ].freeze
+
+      # Definitions used to validate the data.
+      # https://github.com/puppetlabs/bolt/blob/main/schemas/README.md
+      DEFINITIONS = {
+        "alias" => {
+          description: "A unique alias to refer to the target. Aliases cannot conflict "\
+                       "with the name of a group, the name of a target, or another alias.",
+          type: [String, Array],
+          uniqueItems: true,
+          items: {
+            type: String,
+            _plugin: true
+          },
+          _plugin: true
+        },
+        "config" => {
+          description: "A map of configuration options.",
+          type: Hash,
+          # These properties are populated as part of Bolt::Inventory.schema
+          properties: {},
+          _plugin: true
+        },
+        "facts" => {
+          description: "A map of system information, also known as facts, for the target.",
+          type: Hash,
+          _plugin: true
+        },
+        "features" => {
+          description: "A list of available features for the target.",
+          type: Array,
+          uniqueItems: true,
+          items: {
+            type: String,
+            _plugin: true
+          },
+          _plugin: true
+        },
+        "groups" => {
+          description: "A list of groups and their associated configuration.",
+          type: Array,
+          items: {
+            type: Hash,
+            required: ["name"],
+            properties: {
+              "config"       => { _ref: "config" },
+              "facts"        => { _ref: "facts" },
+              "features"     => { _ref: "features" },
+              "groups"       => { _ref: "groups" },
+              "name"         => { _ref: "name" },
+              "plugin_hooks" => { _ref: "plugin_hooks" },
+              "targets"      => { _ref: "targets" },
+              "vars"         => { _ref: "vars" }
+            },
+            _plugin: true
+          },
+          _plugin: true
+        },
+        "name" => {
+          description: "A human-readable name to refer to the group or target. Names "\
+                       "cannot conflict with the name of a group, the name of a target, "\
+                       "or the alias of a target. A name is required for a group and is "\
+                       "required for a target unless the uri option is set.",
+          type: String,
+          _plugin: true
+        },
+        "plugin_hooks" => {
+          description: "Configuration for the Puppet library plugin used to install the "\
+                       "Puppet agent on the target. For more information, see "\
+                       "https://pup.pt/bolt-plugin-hooks",
+          type: Hash,
+          properties: {
+            "puppet_library" => {
+              description: "Configuration for the Puppet library plugin.",
+              type: Hash,
+              _plugin: true
+            }
+          },
+          _plugin: true
+        },
+        "targets" => {
+          description: "A list of targets and their associated configuration.",
+          type: Array,
+          items: {
+            type: [String, Hash],
+            properties: {
+              "alias"        => { _ref: "alias" },
+              "config"       => { _ref: "config" },
+              "facts"        => { _ref: "facts" },
+              "features"     => { _ref: "features" },
+              "name"         => { _ref: "name" },
+              "plugin_hooks" => { _ref: "plugin_hooks" },
+              "uri"          => { _ref: "uri" },
+              "vars"         => { _ref: "vars" }
+            },
+            _plugin: true
+          },
+          _plugin: true
+        },
+        "uri" => {
+          description: "The URI of the target. This option is required unless the name "\
+                       "option is set.",
+          type: String,
+          format: "uri",
+          _plugin: true
+        },
+        "vars" => {
+          description: "A map of variables for the group or target.",
+          type: Hash,
+          _plugin: true
+        }
+      }.freeze
+    end
+  end
+end

data/lib/bolt/inventory/target.rb

@@ -31,7 +31,8 @@ module Bolt
         end
 
         if @name == 'localhost'
-          target_data = localhost_defaults(target_data)
+          default = { 'config' => { 'transport' => 'local' } }
+          target_data = Bolt::Util.deep_merge(default, target_data)
         end
 
         @config = target_data['config'] || {}
@@ -49,18 +50,16 @@ module Bolt
         validate
       end
 
-      def localhost_defaults(data)
+      def set_local_defaults
+        return if @set_local_default
         defaults = {
-          'config' => {
-            'transport' => 'local',
-            'local' => { 'interpreters' => { '.rb' => RbConfig.ruby } }
-          },
-          'features' => ['puppet-agent']
+          'local' => { 'interpreters' => { '.rb' => RbConfig.ruby } }
         }
-        data = Bolt::Util.deep_merge(defaults, data)
-        # If features is an empty array deep_merge won't add the puppet-agent
-        data['features'] += ['puppet-agent'] if data['features'].empty?
-        data
+        old_config = @config
+        @config = Bolt::Util.deep_merge(defaults, @config)
+        invalidate_config_cache! if old_config != @config
+        set_feature('puppet-agent')
+        @set_local_default = true
       end
 
       # rubocop:disable Naming/AccessorMethodName

data/lib/bolt/module_installer.rb

@@ -17,14 +17,14 @@ module Bolt
 
     # Adds a single module to the project.
     #
-    def add(name, specs, puppetfile_path, moduledir, config_path)
+    def add(name, specs, puppetfile_path, moduledir, project_file, config)
       project_specs = Specs.new(specs)
 
       # Exit early if project config already includes a spec with this name.
       if project_specs.include?(name)
         @outputter.print_message(
-          "Project configuration file #{config_path} already includes specification with name "\
-          "#{name}. Nothing to do."
+          "Project configuration file #{project_file} already includes specification "\
+          "with name #{name}. Nothing to do."
         )
         return true
       end
@@ -47,30 +47,32 @@ module Bolt
       # a version conflict.
       @outputter.print_action_step("Resolving module dependencies, this may take a moment")
 
+      @outputter.start_spin
       begin
         resolve_specs.add_specs('name' => name)
-        puppetfile = Resolver.new.resolve(resolve_specs)
+        puppetfile = Resolver.new.resolve(resolve_specs, config)
       rescue Bolt::Error
         project_specs.add_specs('name' => name)
-        puppetfile = Resolver.new.resolve(project_specs)
+        puppetfile = Resolver.new.resolve(project_specs, config)
       end
+      @outputter.stop_spin
 
       # Display the diff between the existing Puppetfile and the new Puppetfile.
       print_puppetfile_diff(existing_puppetfile, puppetfile)
 
       # Add the module to the project configuration.
-      @outputter.print_action_step("Updating project configuration file at #{config_path}")
+      @outputter.print_action_step("Updating project configuration file at #{project_file}")
 
-      data = Bolt::Util.read_yaml_hash(config_path, 'project')
+      data = Bolt::Util.read_yaml_hash(project_file, 'project')
       data['modules'] ||= []
       data['modules'] << name.tr('-', '/')
 
       begin
-        File.write(config_path, data.to_yaml)
+        File.write(project_file, data.to_yaml)
       rescue SystemCallError => e
         raise Bolt::FileError.new(
           "Unable to update project configuration file: #{e.message}",
-          config
+          project_file
         )
       end
 
@@ -79,7 +81,7 @@ module Bolt
       puppetfile.write(puppetfile_path, moduledir)
 
       # Install the modules.
-      install_puppetfile(puppetfile_path, moduledir)
+      install_puppetfile(puppetfile_path, moduledir, config)
     end
 
     # Outputs a diff of an old Puppetfile and a new Puppetfile.
@@ -145,7 +147,7 @@ module Bolt
 
     # Installs a project's module dependencies.
     #
-    def install(specs, path, moduledir, force: false, resolve: true)
+    def install(specs, path, moduledir, config = {}, force: false, resolve: true)
       @outputter.print_message("Installing project modules\n\n")
 
       if resolve != false
@@ -155,7 +157,11 @@ module Bolt
         # and write a Puppetfile.
         if force || !path.exist?
           @outputter.print_action_step("Resolving module dependencies, this may take a moment")
-          puppetfile = Resolver.new.resolve(specs)
+
+          # This doesn't use the block as it's more testable to just mock *_spin
+          @outputter.start_spin
+          puppetfile = Resolver.new.resolve(specs, config)
+          @outputter.stop_spin
 
           # We get here either through 'bolt module install' which uses the
           # managed modulepath (which isn't configurable) or through bolt
@@ -177,14 +183,16 @@ module Bolt
       end
 
       # Install the modules.
-      install_puppetfile(path, moduledir)
+      install_puppetfile(path, moduledir, config)
     end
 
     # Installs the Puppetfile and generates types.
     #
     def install_puppetfile(path, moduledir, config = {})
       @outputter.print_action_step("Syncing modules from #{path} to #{moduledir}")
+      @outputter.start_spin
       ok = Installer.new(config).install(path, moduledir)
+      @outputter.stop_spin
 
       # Automatically generate types after installing modules
       @outputter.print_action_step("Generating type references")