bolt 2.38.0 → 3.0.0

data/lib/bolt/cli.rb

@@ -33,19 +33,18 @@ module Bolt
 
   class CLI
     COMMANDS = {
-      'command'    => %w[run],
-      'script'     => %w[run],
-      'task'       => %w[show run],
-      'plan'       => %w[show run convert new],
-      'file'       => %w[download upload],
-      'puppetfile' => %w[install show-modules generate-types],
-      'secret'     => %w[encrypt decrypt createkeys],
-      'inventory'  => %w[show],
-      'group'      => %w[show],
-      'project'    => %w[init migrate],
-      'module'     => %w[add generate-types install show],
-      'apply'      => %w[],
-      'guide'      => %w[]
+      'command' => %w[run],
+      'script' => %w[run],
+      'task' => %w[show run],
+      'plan' => %w[show run convert new],
+      'file' => %w[download upload],
+      'secret' => %w[encrypt decrypt createkeys],
+      'inventory' => %w[show],
+      'group' => %w[show],
+      'project' => %w[init migrate],
+      'module' => %w[add generate-types install show],
+      'apply' => %w[],
+      'guide' => %w[]
     }.freeze
 
     attr_reader :config, :options
@@ -147,10 +146,6 @@ module Bolt
       end
 
       validate(options)
-
-      # Deprecation warnings can't be issued until after config is loaded, so
-      # store them for later.
-      @parser_deprecations = parser.deprecations
     rescue Bolt::Error => e
       fatal_error(e)
       raise e
@@ -159,25 +154,19 @@ module Bolt
     # Loads the project and configuration. All errors that are raised here are not
     # handled by the outputter, as it relies on config being loaded.
     def load_config
-      @config = if ENV['BOLT_PROJECT']
-                  project = Bolt::Project.create_project(ENV['BOLT_PROJECT'], 'environment')
-                  Bolt::Config.from_project(project, options)
-                elsif options[:configfile]
-                  Bolt::Config.from_file(options[:configfile], options)
+      project = if ENV['BOLT_PROJECT']
+                  Bolt::Project.create_project(ENV['BOLT_PROJECT'], 'environment')
+                elsif options[:project]
+                  dir = Pathname.new(options[:project])
+                  if (dir + Bolt::Project::BOLTDIR_NAME).directory?
+                    Bolt::Project.create_project(dir + Bolt::Project::BOLTDIR_NAME)
+                  else
+                    Bolt::Project.create_project(dir)
+                  end
                 else
-                  cli_flag = options[:project] || options[:boltdir]
-                  project = if cli_flag
-                              dir = Pathname.new(cli_flag)
-                              if (dir + Bolt::Project::BOLTDIR_NAME).directory?
-                                Bolt::Project.create_project(dir + Bolt::Project::BOLTDIR_NAME)
-                              else
-                                Bolt::Project.create_project(dir)
-                              end
-                            else
-                              Bolt::Project.find_boltdir(Dir.pwd)
-                            end
-                  Bolt::Config.from_project(project, options)
+                  Bolt::Project.find_boltdir(Dir.pwd)
                 end
+      @config = Bolt::Config.from_project(project, options)
     rescue Bolt::Error => e
       fatal_error(e)
       raise e
@@ -185,20 +174,16 @@ module Bolt
 
     # Completes the setup process by configuring Bolt and log messages
     def finalize_setup
-      Bolt::Logger.configure(config.log, config.color)
+      Bolt::Logger.configure(config.log, config.color, config.disable_warnings)
       Bolt::Logger.analytics = analytics
+      Bolt::Logger.flush_queue
 
       # Logger must be configured before checking path case and project file, otherwise logs will not display
       config.check_path_case('modulepath', config.modulepath)
       config.project.check_deprecated_file
 
-      # Log messages created during parser and config initialization
-      config.logs.each { |log| @logger.send(log.keys[0], log.values[0]) }
-      @parser_deprecations.each { |dep| Bolt::Logger.deprecation_warning(dep[:type], dep[:msg]) }
-      config.deprecations.each { |dep| Bolt::Logger.deprecation_warning(dep[:type], dep[:msg]) }
-
-      if options[:clear_cache] && File.exist?(config.project.cache_file)
-        FileUtils.rm(config.project.cache_file)
+      if options[:clear_cache] && File.exist?(config.project.plugin_cache_file)
+        FileUtils.rm(config.project.plugin_cache_file)
       end
 
       warn_inventory_overrides_cli(options)
@@ -212,12 +197,14 @@ module Bolt
 
     private def validate_ps_version
       if Bolt::Util.powershell?
-        target = inventory.get_target('localhost')
-        Bolt::Transport::Local.new.with_connection(target) do |conn|
-          # This will automatically validate the powershell version on the Bolt
-          # controller
-          Bolt::Shell::Powershell.new(target, conn)
-        end
+        command = "powershell.exe -NoProfile -NonInteractive -NoLogo -ExecutionPolicy "\
+                  "Bypass -Command $PSVersionTable.PSVersion.Major"
+        stdout, _stderr, _status = Open3.capture3(command)
+
+        return unless !stdout.empty? && stdout.to_i < 3
+
+        msg = "Detected PowerShell 2 on controller. PowerShell 2 is unsupported."
+        Bolt::Logger.deprecation_warning("powershell_2_controller", msg)
       end
     end
 
@@ -311,10 +298,6 @@ module Bolt
               "Unknown argument(s) #{options[:leftovers].join(', ')}"
       end
 
-      if options.slice(:boltdir, :configfile, :project).length > 1
-        raise Bolt::CLIError, "Only one of '--boltdir', '--project', or '--configfile' may be specified"
-      end
-
       if options[:noop] &&
          !(options[:subcommand] == 'task' && options[:action] == 'run') && options[:subcommand] != 'apply'
         raise Bolt::CLIError,
@@ -327,10 +310,6 @@ module Bolt
                 "Option '--env-var' may only be specified when running a command or script"
         end
       end
-
-      if options.key?(:debug) && options.key?(:log)
-        raise Bolt::CLIError, "Only one of '--debug' or '--log-level' may be specified"
-      end
     end
 
     def handle_parser_errors
@@ -373,7 +352,10 @@ module Bolt
       conflicting_options = Set.new(opts.keys.map(&:to_s)).intersection(inventory_cli_opts)
 
       if inventory_source && conflicting_options.any?
-        @logger.warn("CLI arguments #{conflicting_options.to_a} may be overridden by Inventory: #{inventory_source}")
+        Bolt::Logger.warn(
+          "cli_overrides",
+          "CLI arguments #{conflicting_options.to_a} may be overridden by Inventory: #{inventory_source}"
+        )
       end
     end
 
@@ -390,7 +372,7 @@ module Bolt
       # Initialize inventory and targets. Errors here are better to catch early.
       # options[:target_args] will contain a string/array version of the targetting options this is passed to plans
       # options[:targets] will contain a resolved set of Target objects
-      unless %w[guide module project puppetfile secret].include?(options[:subcommand]) ||
+      unless %w[guide module project secret].include?(options[:subcommand]) ||
              %w[convert new show].include?(options[:action])
         update_targets(options)
       end
@@ -445,9 +427,6 @@ module Bolt
           list_modules
         end
         return 0
-      when 'show-modules'
-        list_modules
-        return 0
       when 'convert'
         pal.convert_plan(options[:object])
         return 0
@@ -497,17 +476,6 @@ module Bolt
         when 'generate-types'
           code = generate_types
         end
-      when 'puppetfile'
-        case options[:action]
-        when 'generate-types'
-          code = generate_types
-        when 'install'
-          code = install_puppetfile(
-            config.puppetfile_config,
-            config.puppetfile,
-            config.modulepath.first
-          )
-        end
       when 'secret'
         code = Bolt::Secret.execute(plugins, outputter, options)
       when 'apply'
@@ -525,7 +493,6 @@ module Bolt
 
         elapsed_time = Benchmark.realtime do
           executor_opts = {}
-          executor_opts[:description] = options[:description] if options.key?(:description)
           executor_opts[:env_vars] = options[:env_vars] if options.key?(:env_vars)
           executor.subscribe(outputter)
           executor.subscribe(log_outputter)
@@ -538,15 +505,11 @@ module Bolt
               validate_file('script', script)
               executor.run_script(targets, script, options[:leftovers], executor_opts)
             when 'task'
-              r = outputter.spin do
-                pal.run_task(options[:object],
-                             targets,
-                             options[:task_options],
-                             executor,
-                             inventory,
-                             options[:description])
-              end
-              r
+              pal.run_task(options[:object],
+                           targets,
+                           options[:task_options],
+                           executor,
+                           inventory)
             when 'file'
               src = options[:object]
               dest = options[:leftovers].first
@@ -607,7 +570,7 @@ module Bolt
     end
 
     def list_plans
-      plans = filter_content(pal.list_plans(filter_content: true), options[:filter])
+      plans = filter_content(pal.list_plans_with_cache(filter_content: true), options[:filter])
       outputter.print_plans(plans, pal.user_modulepath)
     end
 
@@ -659,7 +622,7 @@ module Bolt
         if node_param && target_param
           msg = "Plan parameters include both 'nodes' and 'targets' with type 'TargetSpec', " \
                 "neither will populated with the value for --nodes or --targets."
-          @logger.warn(msg)
+          Bolt::Logger.warn("nodes_targets_parameters", msg)
         elsif node_param
           plan_arguments['nodes'] = nodes.join(',')
         elsif target_param
@@ -669,7 +632,6 @@ module Bolt
 
       plan_context = { plan_name: plan_name,
                        params: plan_arguments }
-      plan_context[:description] = options[:description] if options[:description]
 
       executor = Bolt::Executor.new(config.concurrency, analytics, options[:noop], config.modified_concurrency)
       if %w[human rainbow].include?(options.fetch(:format, 'human'))
@@ -681,9 +643,7 @@ module Bolt
 
       executor.subscribe(log_outputter)
       executor.start_plan(plan_context)
-      result = outputter.spin do
-        pal.run_plan(plan_name, plan_arguments, executor, inventory, puppetdb_client)
-      end
+      result = pal.run_plan(plan_name, plan_arguments, executor, inventory, puppetdb_client)
 
       # If a non-bolt exception bubbles up the plan won't get finished
       executor.finish_plan(result)
@@ -706,7 +666,7 @@ module Bolt
                   "about defining and declaring classes and types in the Puppet documentation at "\
                   "https://puppet.com/docs/puppet/latest/lang_classes.html and "\
                   "https://puppet.com/docs/puppet/latest/lang_defined_types.html"
-        @logger.warn(message)
+        Bolt::Logger.warn("empty_manifest", message)
       end
 
       executor = Bolt::Executor.new(config.concurrency, analytics, noop, config.modified_concurrency)
@@ -735,14 +695,12 @@ module Bolt
     end
 
     def list_modules
-      assert_puppetfile_or_module_command(config.project.modules)
       outputter.print_module_list(pal.list_modules)
     end
 
     def generate_types
-      assert_puppetfile_or_module_command(config.project.modules)
       # generate_types will surface a nice error with helpful message if it fails
-      pal.generate_types
+      pal.generate_types(cache: true)
       0
     end
 
@@ -750,27 +708,17 @@ module Bolt
     #
     def install_project_modules(project, config, force, resolve)
       assert_project_file(project)
-      assert_puppetfile_or_module_command(project.modules)
 
-      unless project.modules
+      unless project.modules.any?
         outputter.print_message "Project configuration file #{project.project_file} does not "\
                                 "specify any module dependencies. Nothing to do."
         return 0
       end
 
-      if resolve != false && config.any?
-        @logger.warn(
-          "Detected configuration for 'module-install'. This configuration is currently "\
-          "only supported when installing modules, not when resolving module dependencies. "\
-          "For more information, see https://pup.pt/bolt-module-install"
-        )
-      end
-
-      modules   = project.modules || []
       installer = Bolt::ModuleInstaller.new(outputter, pal)
 
       ok = outputter.spin do
-        installer.install(modules,
+        installer.install(project.modules,
                           project.puppetfile,
                           project.managed_moduledir,
                           config,
@@ -785,22 +733,12 @@ module Bolt
     #
     def add_project_module(name, project, config)
       assert_project_file(project)
-      assert_puppetfile_or_module_command(project.modules)
-
-      if config.any?
-        @logger.warn(
-          "Detected configuration for 'module-install'. This configuration is currently "\
-          "only supported when installing modules, not when resolving module dependencies. "\
-          "For more information, see https://pup.pt/bolt-module-install"
-        )
-      end
 
-      modules   = project.modules || []
       installer = Bolt::ModuleInstaller.new(outputter, pal)
 
       ok = outputter.spin do
         installer.add(name,
-                      modules,
+                      project.modules,
                       project.puppetfile,
                       project.managed_moduledir,
                       project.project_file,
@@ -831,8 +769,6 @@ module Bolt
     # Loads a Puppetfile and installs its modules.
     #
     def install_puppetfile(puppetfile_config, puppetfile, moduledir)
-      assert_puppetfile_or_module_command(config.project.modules)
-
       outputter.print_message("Installing modules from Puppetfile")
       installer = Bolt::ModuleInstaller.new(outputter, pal)
       ok = outputter.spin do
@@ -842,43 +778,6 @@ module Bolt
       ok ? 0 : 1
     end
 
-    # Raises an error if the 'puppetfile install' command is deprecated due to
-    # modules being configured.
-    #
-    def assert_puppetfile_or_module_command(modules)
-      if Bolt::Util.powershell?
-        case options[:action]
-        when 'generate-types'
-          old_command = 'Register-BoltPuppetfileTypes'
-          new_command = 'Register-BoltModuleTypes'
-        when 'install'
-          old_command = 'Install-BoltPuppetfile'
-          new_command = 'Install-BoltModule'
-        when 'show', 'show-modules'
-          old_command = 'Get-BoltPuppetfileModules'
-          new_command = 'Get-BoltModule'
-        end
-      else
-        old_command = "bolt puppetfile #{options[:action]}"
-        new_command = if options[:action] == 'show-modules'
-                        'bolt module show'
-                      else
-                        "bolt module #{options[:action]}"
-                      end
-      end
-
-      if modules && options[:subcommand] == 'puppetfile'
-        raise Bolt::CLIError,
-              "Unable to use command '#{old_command}' when 'modules' is configured in "\
-              "bolt-project.yaml. Use '#{new_command}' instead."
-      elsif modules.nil? && options[:subcommand] == 'module'
-        msg  = "Unable to use command '#{new_command}' when 'modules' is not configured in "\
-               "bolt-project.yaml. "
-        msg += "Use '#{old_command}' instead." if options[:action] != 'add'
-        raise Bolt::CLIError, msg
-      end
-    end
-
     def pal
       @pal ||= Bolt::PAL.new(Bolt::Config::Modulepath.new(config.modulepath),
                              config.hiera_config,
@@ -975,7 +874,7 @@ module Bolt
           set the BOLT_GEM environment variable.
         MSG
 
-        @logger.warn(msg)
+        Bolt::Logger.warn("gem_install", msg)
       end
 
       # We only need to enumerate bundled content when running a task or plan

data/lib/bolt/config.rb

@@ -20,10 +20,9 @@ module Bolt
   class Config
     include Bolt::Config::Options
 
-    attr_reader :config_files, :logs, :data, :transports, :project, :modified_concurrency, :deprecations
+    attr_reader :config_files, :data, :transports, :project, :modified_concurrency
 
-    BOLT_CONFIG_NAME = 'bolt.yaml'
-    BOLT_DEFAULTS_NAME = 'bolt-defaults.yaml'
+    DEFAULTS_NAME = 'bolt-defaults.yaml'
 
     # The default concurrency value that is used when the ulimit is not low (i.e. < 700)
     DEFAULT_DEFAULT_CONCURRENCY = 100
@@ -33,70 +32,9 @@ module Bolt
     end
 
     def self.from_project(project, overrides = {})
-      logs         = []
-      deprecations = []
-
-      conf = if project.project_file == project.config_file
-               project.data
-             else
-               c = Bolt::Util.read_optional_yaml_hash(project.config_file, 'config')
-
-               # Validate the config against the schema. This will raise a single error
-               # with all validation errors.
-               Bolt::Validator.new.tap do |validator|
-                 validator.validate(c, bolt_schema, project.config_file.to_s)
-
-                 validator.warnings.each { |warning| logs << { warn: warning } }
-
-                 validator.deprecations.each do |dep|
-                   deprecations << { type: "#{BOLT_CONFIG_NAME} #{dep[:option]}", msg: dep[:message] }
-                 end
-               end
-
-               logs << { debug: "Loaded configuration from #{project.config_file}" } if File.exist?(project.config_file)
-               c
-             end
-      data = load_defaults(project).push(
-        filepath:     project.config_file,
-        data:         conf,
-        logs:         logs,
-        deprecations: deprecations
-      )
-
-      new(project, data, overrides)
-    end
-
-    def self.from_file(configfile, overrides = {})
-      project      = Bolt::Project.create_project(Pathname.new(configfile).expand_path.dirname)
-      logs         = []
-      deprecations = []
-
-      conf = if project.project_file == project.config_file
-               project.data
-             else
-               c = Bolt::Util.read_yaml_hash(configfile, 'config')
-
-               # Validate the config against the schema. This will raise a single error
-               # with all validation errors.
-               Bolt::Validator.new.tap do |validator|
-                 validator.validate(c, bolt_schema, project.config_file.to_s)
-
-                 validator.warnings.each { |warning| logs << { warn: warning } }
-
-                 validator.deprecations.each do |dep|
-                   deprecations << { type: "#{BOLT_CONFIG_NAME} #{dep[:option]}", msg: dep[:message] }
-                 end
-               end
-
-               logs << { debug: "Loaded configuration from #{configfile}" }
-               c
-             end
-
-      data = load_defaults(project).push(
-        filepath:     configfile,
-        data:         conf,
-        logs:         logs,
-        deprecations: deprecations
+      data = load_defaults.push(
+        filepath: project.project_file,
+        data: project.data
       )
 
       new(project, data, overrides)
@@ -115,7 +53,7 @@ module Bolt
     def self.defaults_schema
       schema = {
         type:        Hash,
-        properties:  BOLT_DEFAULTS_OPTIONS.map { |opt| [opt, _ref: opt] }.to_h,
+        properties:  DEFAULTS_OPTIONS.map { |opt| [opt, _ref: opt] }.to_h,
         definitions: OPTIONS.merge(transport_definitions)
       }
 
@@ -124,16 +62,6 @@ module Bolt
       schema
     end
 
-    # Builds the schema for bolt.yaml used by the validator.
-    #
-    def self.bolt_schema
-      {
-        type:        Hash,
-        properties:  (BOLT_OPTIONS + INVENTORY_OPTIONS.keys).map { |opt| [opt, _ref: opt] }.to_h,
-        definitions: OPTIONS.merge(transport_definitions)
-      }
-    end
-
     def self.system_path
       if Bolt::Util.windows?
         Pathname.new(File.join(ENV['ALLUSERSPROFILE'], 'PuppetLabs', 'bolt', 'etc'))
@@ -149,41 +77,31 @@ module Bolt
     end
 
     # Loads a 'bolt-defaults.yaml' file, which contains default configuration that applies to all
-    # projects. This file does not allow project-specific configuration such as 'hiera-config' and
-    # 'inventoryfile', and nests all default inventory configuration under an 'inventory-config' key.
+    # projects. This file does not allow project-specific configuration such as 'hiera-config'
+    # and nests all default inventory configuration under an 'inventory-config' key.
     def self.load_bolt_defaults_yaml(dir)
-      filepath     = dir + BOLT_DEFAULTS_NAME
+      filepath     = dir + DEFAULTS_NAME
       data         = Bolt::Util.read_yaml_hash(filepath, 'config')
-      logs         = [{ debug: "Loaded configuration from #{filepath}" }]
-      deprecations = []
-
-      # Warn if 'bolt.yaml' detected in same directory.
-      if File.exist?(bolt_yaml = dir + BOLT_CONFIG_NAME)
-        logs.push(
-          warn: "Detected multiple configuration files: ['#{bolt_yaml}', '#{filepath}']. '#{bolt_yaml}' "\
-          "will be ignored."
-        )
-      end
+
+      Bolt::Logger.debug("Loaded configuration from #{filepath}")
 
       # Validate the config against the schema. This will raise a single error
       # with all validation errors.
       Bolt::Validator.new.tap do |validator|
         validator.validate(data, defaults_schema, filepath)
-
-        validator.warnings.each { |warning| logs << { warn: warning } }
-
-        validator.deprecations.each do |dep|
-          deprecations << { type: "#{BOLT_DEFAULTS_NAME} #{dep[:option]}", msg: dep[:message] }
-        end
+        validator.warnings.each { |warning| Bolt::Logger.warn(warning[:id], warning[:msg]) }
+        validator.deprecations.each { |dep| Bolt::Logger.deprecate(dep[:id], dep[:msg]) }
       end
 
       # Remove project-specific config such as hiera-config, etc.
-      project_config = data.slice(*(BOLT_PROJECT_OPTIONS - BOLT_DEFAULTS_OPTIONS))
+      project_config = data.slice(*(PROJECT_OPTIONS - DEFAULTS_OPTIONS))
 
       if project_config.any?
         data.reject! { |key, _| project_config.include?(key) }
-        logs.push(
-          warn: "Unsupported project configuration detected in '#{filepath}': #{project_config.keys}. "\
+
+        Bolt::Logger.warn(
+          "unsupported_project_config",
+          "Unsupported project configuration detected in '#{filepath}': #{project_config.keys}. "\
           "Project configuration should be set in 'bolt-project.yaml'."
         )
       end
@@ -193,8 +111,10 @@ module Bolt
 
       if transport_config.any?
         data.reject! { |key, _| transport_config.include?(key) }
-        logs.push(
-          warn: "Unsupported inventory configuration detected in '#{filepath}': #{transport_config.keys}. "\
+
+        Bolt::Logger.warn(
+          "unsupported_inventory_config",
+          "Unsupported inventory configuration detected in '#{filepath}': #{transport_config.keys}. "\
           "Transport configuration should be set under the 'inventory-config' option or "\
           "in 'inventory.yaml'."
         )
@@ -219,55 +139,20 @@ module Bolt
         data = data.merge(data.delete('inventory-config'))
       end
 
-      { filepath: filepath, data: data, logs: logs, deprecations: deprecations }
-    end
-
-    # Loads a 'bolt.yaml' file, the legacy configuration file. There's no special munging needed
-    # here since Bolt::Config will just ignore any invalid keys.
-    def self.load_bolt_yaml(dir)
-      filepath     = dir + BOLT_CONFIG_NAME
-      data         = Bolt::Util.read_yaml_hash(filepath, 'config')
-      logs         = [{ debug: "Loaded configuration from #{filepath}" }]
-      deprecations = [{ type: 'Using bolt.yaml for system configuration',
-                        msg: "Configuration file #{filepath} is deprecated and will be removed in Bolt 3.0. "\
-                        "See https://pup.pt/update-bolt-config for how to update to the latest Bolt practices." }]
-
-      # Validate the config against the schema. This will raise a single error
-      # with all validation errors.
-      Bolt::Validator.new.tap do |validator|
-        validator.validate(data, bolt_schema, filepath)
-
-        validator.warnings.each { |warning| logs << { warn: warning } }
-
-        validator.deprecations.each do |dep|
-          deprecations << { type: "#{BOLT_CONFIG_NAME} #{dep[:option]}", msg: dep[:message] }
-        end
-      end
-
-      { filepath: filepath, data: data, logs: logs, deprecations: deprecations }
+      { filepath: filepath, data: data }
     end
 
-    def self.load_defaults(project)
+    def self.load_defaults
       confs = []
 
-      # Load system-level config. Prefer a 'bolt-defaults.yaml' file, but fall back to the
-      # legacy 'bolt.yaml' file. If the project-level config file is also the system-level
-      # config file, don't load it a second time.
-      if File.exist?(system_path + BOLT_DEFAULTS_NAME)
+      # Load system-level config.
+      if File.exist?(system_path + DEFAULTS_NAME)
         confs << load_bolt_defaults_yaml(system_path)
-      elsif File.exist?(system_path + BOLT_CONFIG_NAME) &&
-            (system_path + BOLT_CONFIG_NAME) != project.config_file
-        confs << load_bolt_yaml(system_path)
       end
 
-      # Load user-level config if there is a homedir. Prefer a 'bolt-defaults.yaml' file, but
-      # fall back to the legacy 'bolt.yaml' file.
-      if user_path
-        if File.exist?(user_path + BOLT_DEFAULTS_NAME)
-          confs << load_bolt_defaults_yaml(user_path)
-        elsif File.exist?(user_path + BOLT_CONFIG_NAME)
-          confs << load_bolt_yaml(user_path)
-        end
+      # Load user-level config if there is a homedir.
+      if user_path && File.exist?(user_path + DEFAULTS_NAME)
+        confs << load_bolt_defaults_yaml(user_path)
       end
 
       confs
@@ -275,33 +160,26 @@ module Bolt
 
     def initialize(project, config_data, overrides = {})
       unless config_data.is_a?(Array)
-        config_data = [{ filepath: project.config_file,
-                         data: config_data,
-                         logs: [],
-                         deprecations: [] }]
+        config_data = [{ filepath: project.project_file, data: config_data }]
       end
 
       @logger       = Bolt::Logger.logger(self)
       @project      = project
-      @logs         = @project.logs.dup
-      @deprecations = @project.deprecations.dup
       @transports   = {}
       @config_files = []
 
       default_data = {
         'apply-settings'      => {},
-        'apply_settings'      => {},
         'color'               => true,
         'compile-concurrency' => Etc.nprocessors,
         'concurrency'         => default_concurrency,
+        'disable-warnings'    => [],
         'format'              => 'human',
         'log'                 => { 'console' => {} },
         'module-install'      => {},
         'plugin-hooks'        => {},
-        'plugin_hooks'        => {},
         'plugins'             => {},
         'puppetdb'            => {},
-        'puppetfile'          => {},
         'save-rerun'          => true,
         'spinner'             => true,
         'transport'           => 'ssh'
@@ -315,9 +193,6 @@ module Bolt
       end
 
       loaded_data = config_data.each_with_object([]) do |data, acc|
-        @logs.concat(data[:logs]) if data[:logs].any?
-        @deprecations.concat(data[:deprecations]) if data[:deprecations].any?
-
         if data[:data].any?
           @config_files.push(data[:filepath])
           acc.push(data[:data])
@@ -347,28 +222,25 @@ module Bolt
     def normalize_overrides(options)
       opts = options.transform_keys(&:to_s)
 
-      # Pull out config options. We need to add 'transport' as it's not part of the
-      # OPTIONS hash but is a valid option that can be set with the --transport CLI option
-      overrides = opts.slice(*OPTIONS.keys, 'transport')
+      # Pull out config options. We need to add 'transport' and 'inventoryfile' as they're
+      # not part of the OPTIONS hash but are valid options that can be set with CLI options
+      overrides = opts.slice(*OPTIONS.keys, 'inventoryfile', 'transport')
 
       # Pull out transport config options
       TRANSPORT_CONFIG.each do |transport, config|
         overrides[transport] = opts.slice(*config.options)
       end
 
-      # Set console log to debug if in debug mode
-      if options[:debug]
-        overrides['log'] = { 'console' => { 'level' => 'debug' } }
-      end
-
-      if options[:puppetfile_path]
-        @puppetfile = options[:puppetfile_path]
-      end
-
       overrides['trace'] = opts['trace'] if opts.key?('trace')
 
-      # Validate the overrides
-      Bolt::Validator.new.validate(overrides, self.class.bolt_schema, 'command line')
+      # Validate the overrides that can have arbitrary values
+      schema = {
+        type:        Hash,
+        properties:  CLI_OPTIONS.map { |opt| [opt, _ref: opt] }.to_h,
+        definitions: OPTIONS.merge(INVENTORY_OPTIONS)
+      }
+
+      Bolt::Validator.new.validate(overrides.slice(*CLI_OPTIONS), schema, 'command line')
 
       overrides
     end
@@ -386,8 +258,11 @@ module Bolt
           when *TRANSPORT_CONFIG.keys
             Bolt::Util.deep_merge(val1, val2)
           # Hash values are shallow merged
-          when 'puppetdb', 'plugin-hooks', 'plugin_hooks', 'apply-settings', 'apply_settings', 'log'
+          when 'apply-settings', 'log', 'plugin-hooks', 'puppetdb'
             val1.merge(val2)
+          # Disabled warnings are concatenated
+          when 'disable-warnings'
+            val1.concat(val2)
           # All other values are overwritten
           else
             val2
@@ -423,7 +298,7 @@ module Bolt
       end
 
       # Filter hashes to only include valid options
-      %w[apply-settings apply_settings module-install puppetfile].each do |opt|
+      %w[apply-settings module-install].each do |opt|
         @data[opt] = @data[opt].slice(*OPTIONS.dig(opt, :properties).keys)
       end
     end
@@ -448,49 +323,19 @@ module Bolt
         next if val == 'disable'
 
         name = normalize_log(key)
-
-        # But otherwise it has to be a Hash
-        unless val.is_a?(Hash)
-          raise Bolt::ValidationError,
-                "config of log #{name} must be a Hash, received #{val.class} #{val.inspect}"
-        end
-
-        acc[name] = val.slice('append', 'level')
-                       .transform_keys(&:to_sym)
-
-        if (v = acc[name][:level])
-          unless v.is_a?(String) || v.is_a?(Symbol)
-            raise Bolt::ValidationError,
-                  "level of log #{name} must be a String or Symbol, received #{v.class} #{v.inspect}"
-          end
-
-          unless Bolt::Logger.valid_level?(v)
-            raise Bolt::ValidationError,
-                  "level of log #{name} must be one of #{Bolt::Logger.levels.join(', ')}; received #{v}"
-          end
-
-          if v == 'notice'
-            @deprecations << {
-              type: 'notice log level',
-              msg:  "Log level 'notice' is deprecated and will be removed in Bolt 3.0. Use 'info' instead."
-            }
-          end
-        end
-
-        if (v = acc[name][:append]) && v != true && v != false
-          raise Bolt::ValidationError,
-                "append flag of log #{name} must be a Boolean, received #{v.class} #{v.inspect}"
-        end
+        acc[name] = val.slice('append', 'level').transform_keys(&:to_sym)
       end
     end
 
     def validate
       if @data['future']
-        msg = "Configuration option 'future' no longer exposes future behavior."
-        @logs << { warn: msg }
+        Bolt::Logger.warn(
+          "future_option",
+          "Configuration option 'future' no longer exposes future behavior."
+        )
       end
 
-      if @project.modules && @data['modulepath']&.include?(@project.managed_moduledir.to_s)
+      if @data['modulepath']&.include?(@project.managed_moduledir.to_s)
         raise Bolt::ValidationError,
               "Found invalid path in modulepath: #{@project.managed_moduledir}. This path "\
               "is automatically appended to the modulepath and cannot be configured."
@@ -508,29 +353,6 @@ module Bolt
       if File.exist?(default_inventoryfile)
         Bolt::Util.validate_file('inventory file', default_inventoryfile)
       end
-
-      unless TRANSPORT_CONFIG.include?(transport)
-        raise UnknownTransportError, transport
-      end
-
-      # Warn the user how they should be using the 'puppetfile' or
-      # 'module-install' config options. We don't error here since these
-      # settings can be set at the user or system level.
-      if @project.modules && puppetfile_config.any? && module_install.empty?
-        command = Bolt::Util.powershell? ? 'Update-BoltProject' : 'bolt project migrate'
-        @logs << { warn: "Detected configuration for 'puppetfile'. This setting is not "\
-                         "used when 'modules' is configured. Use 'module-install' instead. "\
-                         "To automatically update your project configuration, run '#{command}'." }
-      elsif @project.modules.nil? && puppetfile_config.empty? && module_install.any?
-        @logs << { warn: "Detected configuration for 'module-install'. This setting is not "\
-                         "used when 'modules' is not configured. Use 'puppetfile' instead." }
-      elsif @project.modules && puppetfile_config.any? && module_install.any?
-        @logs << { warn: "Detected configuration for 'puppetfile' and 'module-install'. Using "\
-                         "configuration for 'module-install' because 'modules' is also configured." }
-      elsif @project.modules.nil? && puppetfile_config.any? && module_install.any?
-        @logs << { warn: "Detected configuration for 'puppetfile' and 'module-install'. Using "\
-                         "configuration for 'puppetfile' because 'modules' is not configured." }
-      end
     end
 
     def default_inventoryfile
@@ -546,21 +368,15 @@ module Bolt
     end
 
     def puppetfile
-      @puppetfile || @project.puppetfile
+      @project.puppetfile
     end
 
     def modulepath
-      path = @data['modulepath'] || @project.modulepath
-
-      if @project.modules
-        path + [@project.managed_moduledir.to_s]
-      else
-        path
-      end
+      (@data['modulepath'] || @project.modulepath) + [@project.managed_moduledir.to_s]
     end
 
     def modulepath=(value)
-      @data['modulepath'] = value
+      @data['modulepath'] = Array(value)
     end
 
     def plugin_cache
@@ -611,27 +427,12 @@ module Bolt
       @data['compile-concurrency']
     end
 
-    def puppetfile_config
-      @data['puppetfile']
-    end
-
     def plugins
       @data['plugins']
     end
 
     def plugin_hooks
-      if @data['plugin-hooks'].any? && @data['plugin_hooks'].any?
-        Bolt::Logger.warn_once(
-          "plugin-hooks and plugin_hooks set",
-          "Detected configuration for 'plugin-hooks' and 'plugin_hooks'. Bolt will ignore 'plugin_hooks'."
-        )
-
-        @data['plugin-hooks']
-      elsif @data['plugin-hooks'].any?
-        @data['plugin-hooks']
-      else
-        @data['plugin_hooks']
-      end
+      @data['plugin-hooks']
     end
 
     def trusted_external
@@ -639,18 +440,7 @@ module Bolt
     end
 
     def apply_settings
-      if @data['apply-settings'].any? && @data['apply_settings'].any?
-        Bolt::Logger.warn_once(
-          "apply-settings and apply_settings set",
-          "Detected configuration for 'apply-settings' and 'apply_settings'. Bolt will ignore 'apply_settings'."
-        )
-
-        @data['apply-settings']
-      elsif @data['apply-settings'].any?
-        @data['apply-settings']
-      else
-        @data['apply_settings']
-      end
+      @data['apply-settings']
     end
 
     def transport
@@ -661,6 +451,10 @@ module Bolt
       @project.module_install || @data['module-install']
     end
 
+    def disable_warnings
+      Set.new(@project.disable_warnings + @data['disable-warnings'])
+    end
+
     # Check if there is a case-insensitive match to the path
     def check_path_case(type, paths)
       return if paths.nil?
@@ -669,7 +463,7 @@ module Bolt
       if matches.any?
         msg = "WARNING: Bolt is case sensitive when specifying a #{type}. Did you mean:\n"
         matches.each { |path| msg += "         #{path}\n" }
-        @logger.warn msg
+        Bolt::Logger.warn("path_case", msg)
       end
     end