bolt 2.42.0 → 3.3.0

data/lib/bolt/catalog.rb

@@ -76,31 +76,27 @@ module Bolt
       # is the only way to log a message that will make it back to Bolt
       # to be printed.
       target = request['target']
-      plan_vars = shadow_vars('plan', request['plan_vars'], target['facts'])
-      target_vars = shadow_vars('target', target['variables'], target['facts'])
 
-      # Merge plan vars with target vars, while maintaining the order of the plan
-      # vars. It's critical that the order of plan vars is not changed, as Puppet
-      # will deserialize the variables in the order they appear. Variables may
-      # contain local references to variables that appear earlier in a plan. If
-      # these variables are moved before the variable they reference, Puppet will
-      # be unable to deserialize the data and raise an error.
-      topscope_vars = target_vars.reject { |k, _v| plan_vars.key?(k) }.merge(plan_vars)
+      variables = {
+        variables:        request['plan_vars'],
+        target_variables: target['variables']
+      }
 
-      env_conf = { modulepath: request['modulepath'],
-                   facts: target['facts'],
-                   variables: topscope_vars }
+      env_conf = {
+        modulepath: request['modulepath'],
+        facts:      target['facts']
+      }
 
       puppet_settings = {
         node_name_value: target['name'],
-        hiera_config: request['hiera_config']
+        hiera_config:    request['hiera_config']
       }
 
       with_puppet_settings(puppet_settings) do
         Puppet::Pal.in_tmp_environment('bolt_catalog', **env_conf) do |pal|
           Puppet.override(puppet_overrides) do
             Puppet.lookup(:pal_current_node).trusted_data = target['trusted']
-            pal.with_catalog_compiler do |compiler|
+            pal.with_catalog_compiler(**variables) do |compiler|
               options = request['puppet_config'] || {}
               # Configure language strictness in the CatalogCompiler. We want Bolt to be able
               # to compile most Puppet 4+ manifests, so we default to allowing deprecated functions.
@@ -119,21 +115,6 @@ module Bolt
       end
     end
 
-    # Warn and remove variables that will be shadowed by facts of the same
-    # name, which are set in scope earlier.
-    def shadow_vars(type, vars, facts)
-      collisions, valid = vars.partition do |k, _|
-        facts.include?(k)
-      end
-      if collisions.any?
-        names = collisions.map { |k, _| "$#{k}" }.join(', ')
-        plural = collisions.length == 1 ? '' : 's'
-        Puppet.warning("#{type.capitalize} variable#{plural} #{names} will be overridden by fact#{plural} " \
-                       "of the same name in the apply block")
-      end
-      valid.to_h
-    end
-
     def build_program(code)
       ast = Puppet::Pops::Serialization::FromDataConverter.convert(code)
 

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,17 @@ 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.stream = config.stream
       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)
@@ -218,9 +204,8 @@ module Bolt
 
         return unless !stdout.empty? && stdout.to_i < 3
 
-        msg = "Detected PowerShell 2 on controller. PowerShell 2 is deprecated and "\
-              "support will be removed in Bolt 3.0."
-        Bolt::Logger.deprecation_warning("PowerShell 2 controller", msg)
+        msg = "Detected PowerShell 2 on controller. PowerShell 2 is unsupported."
+        Bolt::Logger.deprecation_warning("powershell_2_controller", msg)
       end
     end
 
@@ -228,7 +213,7 @@ module Bolt
       target_opts = options.keys.select { |opt| %i[query rerun targets].include?(opt) }
       target_string = "'--targets', '--rerun', or '--query'"
       if target_opts.length > 1
-        raise Bolt::CLIError, "Only one targeting option #{target_string} may be specified"
+        raise Bolt::CLIError, "Only one targeting option #{target_string} can be specified"
       elsif target_opts.empty? && options[:subcommand] != 'plan'
         raise Bolt::CLIError, "Command requires a targeting option: #{target_string}"
       end
@@ -265,11 +250,14 @@ module Bolt
         end
       end
 
-      if %w[task plan].include?(options[:subcommand]) && options[:action] == 'run'
+      if %w[task plan script].include?(options[:subcommand]) && options[:action] == 'run'
         if options[:object].nil?
           raise Bolt::CLIError, "Must specify a #{options[:subcommand]} to run"
         end
-        # This may mean that we parsed a parameter as the object
+      end
+
+      # This may mean that we parsed a parameter as the object
+      if %w[task plan].include?(options[:subcommand]) && options[:action] == 'run'
         unless options[:object] =~ /\A([a-z][a-z0-9_]*)?(::[a-z][a-z0-9_]*)*\Z/
           raise Bolt::CLIError,
                 "Invalid #{options[:subcommand]} '#{options[:object]}'"
@@ -314,26 +302,18 @@ 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,
-              "Option '--noop' may only be specified when running a task or applying manifest code"
+              "Option '--noop' can only be specified when running a task or applying manifest code"
       end
 
       if options[:env_vars]
         unless %w[command script].include?(options[:subcommand]) && options[:action] == 'run'
           raise Bolt::CLIError,
-                "Option '--env-var' may only be specified when running a command or script"
+                "Option '--env-var' can 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
@@ -376,7 +356,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} might be overridden by Inventory: #{inventory_source}"
+        )
       end
     end
 
@@ -393,7 +376,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
@@ -448,15 +431,12 @@ module Bolt
           list_modules
         end
         return 0
-      when 'show-modules'
-        list_modules
-        return 0
       when 'convert'
         pal.convert_plan(options[:object])
         return 0
       end
 
-      message = 'There may be processes left executing on some nodes.'
+      message = 'There might be processes left executing on some nodes.'
 
       if %w[task plan].include?(options[:subcommand]) && options[:task_options] && !options[:params_parsed] && pal
         options[:task_options] = pal.parse_params(options[:subcommand], options[:object], options[:task_options])
@@ -500,17 +480,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'
@@ -528,7 +497,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)
@@ -537,19 +505,14 @@ module Bolt
             when 'command'
               executor.run_command(targets, options[:object], executor_opts)
             when 'script'
-              script = options[:object]
-              validate_file('script', script)
-              executor.run_script(targets, script, options[:leftovers], executor_opts)
+              script_path = find_file(options[:object])
+              executor.run_script(targets, script_path, 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
@@ -610,7 +573,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
 
@@ -650,7 +613,7 @@ module Bolt
         if plan_arguments['nodes'] || plan_arguments['targets']
           key = plan_arguments.include?('nodes') ? 'nodes' : 'targets'
           raise Bolt::CLIError,
-                "A plan's '#{key}' parameter may be specified using the --#{key} option, but in that " \
+                "A plan's '#{key}' parameter can be specified using the --#{key} option, but in that " \
                 "case it must not be specified as a separate #{key}=<value> parameter nor included " \
                 "in the JSON data passed in the --params option"
         end
@@ -662,7 +625,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
@@ -672,7 +635,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'))
@@ -684,9 +646,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)
@@ -709,7 +669,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)
@@ -738,14 +698,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
 
@@ -753,19 +711,19 @@ module Bolt
     #
     def install_project_modules(project, config, force, resolve)
       assert_project_file(project)
-      assert_puppetfile_or_module_command(project.modules)
 
-      unless project.modules
-        outputter.print_message "Project configuration file #{project.project_file} does not "\
-                                "specify any module dependencies. Nothing to do."
+      if project.modules.empty? && resolve != false
+        outputter.print_message(
+          "Project configuration file #{project.project_file} does not "\
+          "specify any module dependencies. Nothing to do."
+        )
         return 0
       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,
@@ -780,14 +738,12 @@ module Bolt
     #
     def add_project_module(name, project, config)
       assert_project_file(project)
-      assert_puppetfile_or_module_command(project.modules)
 
-      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,
@@ -818,8 +774,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
@@ -829,47 +783,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] == 'puppetfile'
-        msg = "Command '#{old_command}' is deprecated and will be removed in Bolt 3.0. Update your project to use "\
-              "the module management feature. For more information, see https://pup.pt/bolt-module-migrate."
-        Bolt::Logger.deprecation_warning('puppetfile command', msg)
-      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,
@@ -930,6 +843,28 @@ module Bolt
       Bolt::Util.validate_file(type, path, allow_dir)
     end
 
+    # Returns the path to a file. If the path is an absolute or relative to
+    # a file, and the file exists, returns the path as-is. Otherwise, checks if
+    # the path is a Puppet file path and looks for the file in a module's files
+    # directory.
+    #
+    def find_file(path)
+      unless File.exist?(path) || Pathname.new(path).absolute?
+        modulepath = Bolt::Config::Modulepath.new(config.modulepath)
+        modules    = Bolt::Module.discover(modulepath.full_modulepath, config.project)
+        mod, file = path.split(File::SEPARATOR, 2)
+
+        if modules[mod]
+          @logger.debug("Did not find file at #{File.expand_path(path)}, checking in module '#{mod}'")
+          path = File.join(modules[mod].path, 'files', file)
+        end
+      end
+
+      Bolt::Util.validate_file('script', path)
+
+      path
+    end
+
     def rerun
       @rerun ||= Bolt::Rerun.new(config.rerunfile, config.save_rerun)
     end
@@ -958,7 +893,7 @@ module Bolt
       # If the bundled content directory is empty, Bolt is likely installed as a gem.
       if ENV['BOLT_GEM'].nil? && incomplete_install?
         msg = <<~MSG.chomp
-          Bolt may be installed as a gem. To use Bolt reliably and with all of its
+          Bolt might be installed as a gem. To use Bolt reliably and with all of its
           dependencies, uninstall the 'bolt' gem and install Bolt as a package:
           https://puppet.com/docs/bolt/latest/bolt_installing.html
 
@@ -966,7 +901,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
@@ -989,7 +924,8 @@ module Bolt
     # Gem installs include the aggregate, canary, and puppetdb_fact modules, while
     # package installs include modules listed in the Bolt repo Puppetfile
     def incomplete_install?
-      (Dir.children(Bolt::Config::Modulepath::MODULES_PATH) - %w[aggregate canary puppetdb_fact secure_env_vars]).empty?
+      builtin_module_list = %w[aggregate canary puppetdb_fact secure_env_vars puppet_connect]
+      (Dir.children(Bolt::Config::Modulepath::MODULES_PATH) - builtin_module_list).empty?
     end
 
     # Mimicks the output from Outputter::Human#fatal_error. This should be used to print