bolt 0.21.3 → 0.21.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfc1d47b6d45382d603a222c1aa4a5066a560e4439799afc00a15b44002497fb
-  data.tar.gz: 9e1c7c4c69d255092849484da518a6c9c02115917f8f5f3475ee8669b322bf70
+  metadata.gz: 81d6e90b40ddb51ff8c5b4817ba930417ec7aec118a63e8b585b38d6a5555040
+  data.tar.gz: 3e99e5ba914908058503d1feb9bd8fe5331474288d863ec158a798142b0f41be
 SHA512:
-  metadata.gz: 29dd0f53e14ef2d7787e59ddf121f3a96a27c7b0810b3971a55a377c2e0f5d0996f78359e685459edbafea7a78e2e284b454027e22906edde2790bc9452ed23b
-  data.tar.gz: cb7268a4c9de0d2b8fd99649d112276c8542275b8f3ce7e134f7b1b2a041cb688537e13ce98a607753c597eec028ff1fb29c09ad1b18ead6aa291014e4dfb91d
+  metadata.gz: 9e7d9c78f78df1dffa0e4288cefa10216182091c16b70ace73b6e1a766a4ebff7fc6cedb403b9794851c844b9050c63a13f1beb137a87e5f53af2c9b2de7af54
+  data.tar.gz: 1edc8a0cb84632e703a9c2b0e50d6478cdbb2e5a56e0bb7bc06e9395e6dba1bcbc7232423eca87afef58f904c5922af782041079070b819f08d5228dbb3c029b

data/exe/bolt-inventory-pdb

@@ -3,5 +3,11 @@
 
 require 'bolt_ext/puppetdb_inventory'
 
-exitcode = Bolt::PuppetDBInventory::CLI.new(ARGV).run
-exit exitcode
+begin
+  Bolt::PuppetDBInventory::CLI.new(ARGV).run
+  exit 0
+rescue StandardError => e
+  warn "Error: #{e}"
+  warn e.backtrace if @trace
+  exit 1
+end

data/lib/bolt/applicator.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'logging'
 require 'open3'
 require 'concurrent'
+require 'bolt/util/puppet_log_level'
 
 module Bolt
   Task = Struct.new(:name, :implementations, :input_method)
 
   class Applicator
-    def initialize(inventory, executor, modulepath, pdb_config, hiera_config, max_compiles)
+    def initialize(inventory, executor, modulepath, pdb_client, hiera_config, max_compiles)
       @inventory = inventory
       @executor = executor
       @modulepath = modulepath
-      @pdb_config = pdb_config
+      @pdb_client = pdb_client
       @hiera_config = hiera_config ? validate_hiera_config(hiera_config) : nil
 
       @pool = Concurrent::ThreadPoolExecutor.new(max_threads: max_compiles)
+      @logger = Logging.logger[self]
     end
 
     private def libexec
@@ -36,7 +39,7 @@ module Bolt
       catalog_input = {
         code_ast: ast,
         modulepath: @modulepath,
-        pdb_config: @pdb_config,
+        pdb_config: @pdb_client.config.to_hash,
         hiera_config: @hiera_config,
         target: {
           name: target.host,
@@ -53,7 +56,28 @@ module Bolt
       out, err, stat = Open3.capture3('ruby', bolt_catalog_exe, 'compile', stdin_data: catalog_input.to_json)
       ENV['PATH'] = old_path
 
-      raise ApplyError.new(target.to_s, err) unless stat.success?
+      # stderr may contain formatted logs from Puppet's logger or other errors.
+      # Print them in order, but handle them separately. Anything not a formatted log is assumed
+      # to be an error message.
+      logs = err.lines.map do |l|
+        begin
+          JSON.parse(l)
+        rescue StandardError
+          l
+        end
+      end
+      logs.each do |log|
+        if log.is_a?(String)
+          @logger.error(log.chomp)
+        else
+          log.map { |k, v| [k.to_sym, v] }.each do |level, msg|
+            bolt_level = Bolt::Util::PuppetLogLevel::MAPPING[level]
+            @logger.send(bolt_level, "#{target.name}: #{msg.chomp}")
+          end
+        end
+      end
+
+      raise(ApplyError, target.name) unless stat.success?
       JSON.parse(out)
     end
 
@@ -61,22 +85,70 @@ module Bolt
       if File.exist?(File.path(hiera_config))
         data = File.open(File.path(hiera_config), "r:UTF-8") { |f| YAML.safe_load(f.read) }
         unless data['version'] == 5
-          raise ApplyError.new("All Targets", "Hiera v5 is required.")
+          raise Bolt::ParseError, "Hiera v5 is required, found v#{data['version'] || 3} in #{hiera_config}"
         end
         hiera_config
       end
     end
 
+    def provide_puppet_missing_errors(result)
+      error_hash = result.error_hash
+      exit_code = error_hash['details']['exit_code'] if error_hash && error_hash['details']
+      # If we get exit code 126 or 127 back, it means the shebang command wasn't found; Puppet isn't present
+      if [126, 127].include?(exit_code)
+        Result.new(result.target, error:
+          {
+            'msg' => "Puppet is not installed on the target, please install it to enable 'apply'",
+            'kind' => 'bolt/apply-error'
+          })
+      elsif exit_code == 1 && error_hash['msg'] =~ /Could not find executable 'ruby.exe'/
+        # Windows does not have Ruby present
+        Result.new(result.target, error:
+          {
+            'msg' => "Puppet is not installed on the target in $env:ProgramFiles, please install it to enable 'apply'",
+            'kind' => 'bolt/apply-error'
+          })
+      elsif exit_code == 1 && error_hash['msg'] =~ /cannot load such file -- puppet \(LoadError\)/
+        # Windows uses a Ruby that doesn't have Puppet installed
+        # TODO: fix so we don't find other Rubies, or point to a known issues URL for more info
+        Result.new(result.target, error:
+          {
+            'msg' => 'Found a Ruby without Puppet present, please install Puppet ' \
+                     "or remove Ruby from $env:Path to enable 'apply'",
+            'kind' => 'bolt/apply-error'
+          })
+      else
+        result
+      end
+    end
+
+    def identify_resource_failures(result)
+      if result.ok? && result.value['status'] == 'failed'
+        resources = result.value['resource_statuses']
+        failed = resources.select { |_, r| r['failed'] }.flat_map do |key, resource|
+          resource['events'].select { |e| e['status'] == 'failure' }.map do |event|
+            "\n  #{key}: #{event['message']}"
+          end
+        end
+
+        result.value['_error'] = {
+          'msg' => "Resources failed to apply for #{result.target.name}#{failed.join}",
+          'kind' => 'bolt/resource-failure'
+        }
+      end
+      result
+    end
+
     def apply(args, apply_body, scope)
       raise(ArgumentError, 'apply requires a TargetSpec') if args.empty?
       type0 = Puppet.lookup(:pal_script_compiler).type('TargetSpec')
       Puppet::Pal.assert_type(type0, args[0], 'apply targets')
 
-      params = {}
+      options = {}
       if args.count > 1
         type1 = Puppet.lookup(:pal_script_compiler).type('Hash[String, Data]')
         Puppet::Pal.assert_type(type1, args[1], 'apply options')
-        params = args[1]
+        options = args[1]
       end
 
       # collect plan vars and merge them over target vars
@@ -87,7 +159,7 @@ module Bolt
       ast = Puppet::Pops::Serialization::ToDataConverter.convert(apply_body, rich_data: true, symbol_to_string: true)
       notify = proc { |_| nil }
 
-      @executor.log_action('apply catalog', targets) do
+      r = @executor.log_action('apply catalog', targets) do
         futures = targets.map do |target|
           Concurrent::Future.execute(executor: @pool) do
             @executor.with_node_logging("Compiling manifest block", [target]) do
@@ -99,16 +171,22 @@ module Bolt
         result_promises = targets.zip(futures).flat_map do |target, future|
           @executor.queue_execute([target]) do |transport, batch|
             @executor.with_node_logging("Applying manifest block", batch) do
-              arguments = params.clone
-              arguments['catalog'] = future.value
+              arguments = { 'catalog' => future.value, '_noop' => options['_noop'] }
               raise future.reason if future.rejected?
-              transport.batch_task(batch, catalog_apply_task, arguments, {}, &notify)
+              result = transport.batch_task(batch, catalog_apply_task, arguments, options, &notify)
+              result = provide_puppet_missing_errors(result)
+              identify_resource_failures(result)
             end
           end
         end
 
         @executor.await_results(result_promises)
       end
+
+      if !r.ok && !options['_catch_errors']
+        raise Bolt::ApplyFailure, r
+      end
+      r
     end
   end
 end

data/lib/bolt/bolt_option_parser.rb

@@ -28,6 +28,7 @@ Available subcommands:
   bolt plan show                   Show list of available plans
   bolt plan show <plan>            Show details for plan
   bolt plan run <plan> [params]    Run a Puppet task plan
+  bolt puppetfile install          Install modules from a Puppetfile into a Boltdir
 
 Run `bolt <subcommand> --help` to view specific examples.
 
@@ -89,6 +90,18 @@ Available actions are:
   upload <src> <dest>              Upload local file <src> to <dest> on each node
 
 #{examples('file upload /tmp/source /etc/profile.d/login.sh', 'upload a file to')}
+Available options are:
+    HELP
+
+    PUPPETFILE_HELP = <<-HELP
+Usage: bolt puppetfile <action> [options]
+
+Available actions are:
+  install                          Install modules from a Puppetfile into a Boltdir
+
+Install modules into the local Boltdir
+  bolt puppetfile install
+
 Available options are:
     HELP
 
@@ -193,7 +206,7 @@ Available options are:
       end
       define('--boltdir FILEPATH',
              'Specify what Boltdir to load config from (default: autodiscovered from current working dir)') do |path|
-        @options[:configfile] = path
+        @options[:boltdir] = path
       end
       define('--configfile FILEPATH',
              'Specify where to load config from (default: ~/.puppetlabs/bolt/bolt.yaml)') do |path|
@@ -253,8 +266,8 @@ Available options are:
       # show the --nodes and --query switches by default
       @nodes.hide = @query.hide = false
 
-      # Update the banner according to the mode
-      self.banner = case @options[:mode]
+      # Update the banner according to the subcommand
+      self.banner = case @options[:subcommand]
                     when 'plan'
                       # don't show the --nodes and --query switches in the plan help
                       @nodes.hide = @query.hide = true
@@ -267,6 +280,8 @@ Available options are:
                       TASK_HELP
                     when 'file'
                       FILE_HELP
+                    when 'puppetfile'
+                      PUPPETFILE_HELP
                     else
                       BANNER
                     end

data/lib/bolt/boltdir.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Bolt
+  class Boltdir
+    BOLTDIR_NAME = 'Boltdir'
+
+    attr_reader :path, :config_file, :inventory_file, :modulepath, :hiera_config, :puppetfile
+
+    def self.default_boltdir
+      Boltdir.new(File.join('~', '.puppetlabs', 'bolt'))
+    end
+
+    def self.find_boltdir(dir)
+      local_boltdir = Pathname.new(dir).ascend do |path|
+        boltdir = path + BOLTDIR_NAME
+        break new(boltdir) if boltdir.directory?
+      end
+
+      local_boltdir || default_boltdir
+    end
+
+    def initialize(path)
+      @path = Pathname.new(path).expand_path
+      @config_file = @path + 'bolt.yaml'
+      @inventory_file = @path + 'inventory.yaml'
+      @modulepath = [(@path + 'modules').to_s]
+      @hiera_config = @path + 'hiera.yaml'
+      @puppetfile = @path + 'Puppetfile'
+    end
+
+    def to_s
+      @path.to_s
+    end
+
+    def eql?(other)
+      path == other.path
+    end
+    alias == eql?
+  end
+end

data/lib/bolt/catalog.rb

@@ -2,56 +2,11 @@
 
 require 'bolt/pal'
 require 'bolt/puppetdb'
-require 'bolt/util/on_access'
 
 Bolt::PAL.load_puppet
 
-# This class exists to override evaluate_main and let us inject
-# AST instead of looking for the main manifest. A better option may be to set up the
-# node environment so our AST is in the '' hostclass instead of doing it here.
-module Puppet
-  module Parser
-    class BoltCompiler < Puppet::Parser::Compiler
-      def internal_evaluator
-        @internal_evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new
-      end
-
-      def dump_ast(ast)
-        Puppet::Pops::Serialization::ToDataConverter.convert(ast, rich_data: true, symbol_to_string: true)
-      end
-
-      def load_ast(ast_data)
-        Puppet::Pops::Serialization::FromDataConverter.convert(ast_data)
-      end
-
-      def parse_string(string, file = '')
-        internal_evaluator.parse_string(string, file)
-      end
-
-      def evaluate_main
-        main = Puppet.lookup(:pal_main)
-        ast = if main.is_a?(String)
-                parse_string(main)
-              else
-                load_ast(main)
-              end
-
-        bridge = Puppet::Parser::AST::PopsBridge::Program.new(ast)
-
-        # This is more or less copypaste from the super but we don't use the
-        # original host_class.
-        krt = environment.known_resource_types
-        @main = krt.add(Puppet::Resource::Type.new(:hostclass, '', code: bridge))
-        @topscope.source = @main
-        @main_resource = Puppet::Parser::Resource.new('class', :main, scope: @topscope, source: @main)
-        @topscope.resource = @main_resource
-        add_resource(@topscope, @main_resource)
-
-        @main_resource.evaluate
-      end
-    end
-  end
-end
+require 'bolt/catalog/compiler'
+require 'bolt/catalog/logging'
 
 module Bolt
   class Catalog
@@ -64,7 +19,10 @@ module Bolt
         Puppet.settings.send(:clear_everything_for_tests)
         Puppet.initialize_settings(cli)
         Puppet.settings[:hiera_config] = hiera_config
-        # self.class.configure_logging
+
+        # Use a special logdest that serializes all log messages and their level to stderr.
+        Puppet::Util::Log.newdestination(:stderr)
+        Puppet.settings[:log_level] = 'debug'
         yield
       end
     end
@@ -97,10 +55,7 @@ module Bolt
       pal_main = request['code_ast'] || request['code_string']
       target = request['target']
 
-      pdb_client = Bolt::Util::OnAccess.new do
-        pdb_config = Bolt::PuppetDB::Config.new(nil, request['pdb_config'])
-        Bolt::PuppetDB::Client.from_config(pdb_config)
-      end
+      pdb_client = Bolt::PuppetDB::Client.new(Bolt::PuppetDB::Config.new(request['pdb_config']))
 
       with_puppet_settings(request['hiera_config']) do
         Puppet[:code] = ''

data/lib/bolt/catalog/compiler.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# This class exists to override evaluate_main and let us inject
+# AST instead of looking for the main manifest. A better option may be to set up the
+# node environment so our AST is in the '' hostclass instead of doing it here.
+module Puppet
+  module Parser
+    class BoltCompiler < Puppet::Parser::Compiler
+      def internal_evaluator
+        @internal_evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new
+      end
+
+      def dump_ast(ast)
+        Puppet::Pops::Serialization::ToDataConverter.convert(ast, rich_data: true, symbol_to_string: true)
+      end
+
+      def load_ast(ast_data)
+        Puppet::Pops::Serialization::FromDataConverter.convert(ast_data)
+      end
+
+      def parse_string(string, file = '')
+        internal_evaluator.parse_string(string, file)
+      end
+
+      def evaluate_main
+        main = Puppet.lookup(:pal_main)
+        ast = if main.is_a?(String)
+                parse_string(main)
+              else
+                load_ast(main)
+              end
+
+        bridge = Puppet::Parser::AST::PopsBridge::Program.new(ast)
+
+        # This is more or less copypaste from the super but we don't use the
+        # original host_class.
+        krt = environment.known_resource_types
+        @main = krt.add(Puppet::Resource::Type.new(:hostclass, '', code: bridge))
+        @topscope.source = @main
+        @main_resource = Puppet::Parser::Resource.new('class', :main, scope: @topscope, source: @main)
+        @topscope.resource = @main_resource
+        add_resource(@topscope, @main_resource)
+
+        @main_resource.evaluate
+      end
+    end
+  end
+end

data/lib/bolt/catalog/logging.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Puppet::Util::Log.newdesttype :stderr do
+  def initialize
+    # Flush output immediately.
+    $stderr.sync = true
+  end
+
+  # Emits message as a single line of JSON mapping level to message string.
+  def handle(msg)
+    str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
+    str = msg.source == "Puppet" ? str : "#{msg.source}: #{str}"
+    warn({ msg.level => str }.to_json)
+  end
+end

data/lib/bolt/cli.rb

@@ -6,6 +6,7 @@ require 'json'
 require 'io/console'
 require 'logging'
 require 'optparse'
+require 'r10k/action/puppetfile/install'
 require 'bolt/analytics'
 require 'bolt/bolt_option_parser'
 require 'bolt/config'
@@ -16,26 +17,27 @@ require 'bolt/logger'
 require 'bolt/outputter'
 require 'bolt/puppetdb'
 require 'bolt/pal'
+require 'bolt/r10k_log_proxy'
 require 'bolt/target'
 require 'bolt/version'
-require 'bolt/util/on_access'
 
 module Bolt
   class CLIExit < StandardError; end
   class CLI
-    COMMANDS = { 'command' => %w[run],
-                 'script'  => %w[run],
-                 'task'    => %w[show run],
-                 'plan'    => %w[show run],
-                 'file'    => %w[upload] }.freeze
+    COMMANDS = { 'command'    => %w[run],
+                 'script'     => %w[run],
+                 'task'       => %w[show run],
+                 'plan'       => %w[show run],
+                 'file'       => %w[upload],
+                 'puppetfile' => %w[install] }.freeze
 
     attr_reader :config, :options
 
     def initialize(argv)
       Bolt::Logger.initialize_logging
       @logger = Logging.logger[self]
-      @config = Bolt::Config.new
       @argv = argv
+      @config = Bolt::Config.default
       @options = {
         nodes: []
       }
@@ -48,15 +50,15 @@ module Bolt
     private :inventory
 
     def help?(parser, remaining)
-      # Set the mode
-      options[:mode] = remaining.shift
+      # Set the subcommand
+      options[:subcommand] = remaining.shift
 
-      if options[:mode] == 'help'
+      if options[:subcommand] == 'help'
         options[:help] = true
-        options[:mode] = remaining.shift
+        options[:subcommand] = remaining.shift
       end
 
-      # Update the parser for the new mode
+      # Update the parser for the new subcommand
       parser.update
 
       options[:help]
@@ -73,12 +75,8 @@ module Bolt
         raise Bolt::CLIExit
       end
 
-      config.update(options)
-      config.validate
-      Bolt::Logger.configure(config)
-
       # This section handles parsing non-flag options which are
-      # mode specific rather then part of the config
+      # subcommand specific rather then part of the config
       options[:action] = remaining.shift
       options[:object] = remaining.shift
 
@@ -99,15 +97,28 @@ module Bolt
 
       validate(options)
 
+      @config = if options[:configfile]
+                  Bolt::Config.from_file(options[:configfile], options)
+                else
+                  boltdir = if options[:boltdir]
+                              Bolt::Boltdir.new(options[:boltdir])
+                            else
+                              Bolt::Boltdir.find_boltdir(Dir.pwd)
+                            end
+                  Bolt::Config.from_boltdir(boltdir, options)
+                end
+
+      Bolt::Logger.configure(config.log, config.color)
+
       # After validation, initialize inventory and targets. Errors here are better to catch early.
-      unless options[:action] == 'show'
+      unless options[:subcommand] == 'puppetfile' || options[:action] == 'show'
         if options[:query]
           if options[:nodes].any?
             raise Bolt::CLIError, "Only one of '--nodes' or '--query' may be specified"
           end
           nodes = query_puppetdb_nodes(options[:query])
           options[:targets] = inventory.get_targets(nodes)
-          options[:nodes] = nodes if options[:mode] == 'plan'
+          options[:nodes] = nodes if options[:subcommand] == 'plan'
         else
           options[:targets] = inventory.get_targets(options[:nodes])
         end
@@ -120,42 +131,42 @@ module Bolt
     end
 
     def validate(options)
-      unless COMMANDS.include?(options[:mode])
+      unless COMMANDS.include?(options[:subcommand])
         raise Bolt::CLIError,
-              "Expected subcommand '#{options[:mode]}' to be one of " \
+              "Expected subcommand '#{options[:subcommand]}' to be one of " \
               "#{COMMANDS.keys.join(', ')}"
       end
 
       if options[:action].nil?
         raise Bolt::CLIError,
-              "Expected an action of the form 'bolt #{options[:mode]} <action>'"
+              "Expected an action of the form 'bolt #{options[:subcommand]} <action>'"
       end
 
-      actions = COMMANDS[options[:mode]]
+      actions = COMMANDS[options[:subcommand]]
       unless actions.include?(options[:action])
         raise Bolt::CLIError,
               "Expected action '#{options[:action]}' to be one of " \
               "#{actions.join(', ')}"
       end
 
-      if options[:mode] != 'file' && options[:mode] != 'script' &&
+      if options[:subcommand] != 'file' && options[:subcommand] != 'script' &&
          !options[:leftovers].empty?
         raise Bolt::CLIError,
               "Unknown argument(s) #{options[:leftovers].join(', ')}"
       end
 
-      if %w[task plan].include?(options[:mode]) && options[:action] == 'run'
+      if %w[task plan].include?(options[:subcommand]) && options[:action] == 'run'
         if options[:object].nil?
-          raise Bolt::CLIError, "Must specify a #{options[:mode]} to run"
+          raise Bolt::CLIError, "Must specify a #{options[:subcommand]} to run"
         end
         # This may mean that we parsed a parameter as the object
         unless options[:object] =~ /\A([a-z][a-z0-9_]*)?(::[a-z][a-z0-9_]*)*\Z/
           raise Bolt::CLIError,
-                "Invalid #{options[:mode]} '#{options[:object]}'"
+                "Invalid #{options[:subcommand]} '#{options[:object]}'"
         end
       end
 
-      if options[:mode] != 'plan' && options[:action] != 'show'
+      if !%w[plan puppetfile].include?(options[:subcommand]) && options[:action] != 'show'
         if options[:nodes].empty? && options[:query].nil?
           raise Bolt::CLIError, "Targets must be specified with '--nodes' or '--query'"
         elsif options[:nodes].any? && options[:query]
@@ -163,7 +174,11 @@ module Bolt
         end
       end
 
-      if options[:noop] && (options[:mode] != 'task' || options[:action] != 'run')
+      if options[:boltdir] && options[:configfile]
+        raise Bolt::CLIError, "Only one of '--boltdir' or '--configfile' may be specified"
+      end
+
+      if options[:noop] && (options[:subcommand] != 'task' || options[:action] != 'run')
         raise Bolt::CLIError,
               "Option '--noop' may only be specified when running a task"
       end
@@ -181,10 +196,8 @@ module Bolt
 
     def puppetdb_client
       return @puppetdb_client if @puppetdb_client
-      @puppetdb_client = Bolt::Util::OnAccess.new do
-        puppetdb_config = Bolt::PuppetDB::Config.new(nil, config.puppetdb)
-        Bolt::PuppetDB::Client.from_config(puppetdb_config)
-      end
+      puppetdb_config = Bolt::PuppetDB::Config.load_config(nil, config.puppetdb)
+      @puppetdb_client = Bolt::PuppetDB::Client.new(puppetdb_config)
     end
 
     def query_puppetdb_nodes(query)
@@ -203,38 +216,30 @@ module Bolt
 
       @analytics = Bolt::Analytics.build_client
 
-      screen = "#{options[:mode]}_#{options[:action]}"
+      screen = "#{options[:subcommand]}_#{options[:action]}"
       # submit a different screen for `bolt task show` and `bolt task show foo`
       if options[:action] == 'show' && options[:object]
         screen += '_object'
       end
 
       @analytics.screen_view(screen,
-                             output_format: config[:format],
+                             output_format: config.format,
                              target_nodes: options.fetch(:targets, []).count,
                              inventory_nodes: inventory.node_names.count,
                              inventory_groups: inventory.group_names.count)
 
-      if options[:mode] == 'plan' || options[:mode] == 'task'
-        pal = Bolt::PAL.new(config)
-      end
-
       if options[:action] == 'show'
-        if options[:mode] == 'task'
+        if options[:subcommand] == 'task'
           if options[:object]
-            outputter.print_task_info(pal.get_task_info(options[:object]))
+            show_task(options[:object])
           else
-            outputter.print_table(pal.list_tasks)
-            outputter.print_message("\nUse `bolt task show <task-name>` to view "\
-                                    "details and parameters for a specific task.")
+            list_tasks
           end
-        elsif options[:mode] == 'plan'
+        elsif options[:subcommand] == 'plan'
           if options[:object]
-            outputter.print_plan_info(pal.get_plan_info(options[:object]))
+            show_plan(options[:object])
           else
-            outputter.print_table(pal.list_plans)
-            outputter.print_message("\nUse `bolt plan show <plan-name>` to view "\
-                                    "details and parameters for a specific plan.")
+            list_plans
           end
         end
         return 0
@@ -242,36 +247,16 @@ module Bolt
 
       message = 'There may be processes left executing on some nodes.'
 
-      if options[:task_options] && !options[:params_parsed] && pal
-        options[:task_options] = pal.parse_params(options[:mode], options[:object], options[:task_options])
+      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])
       end
 
-      if options[:mode] == 'plan'
-        unless options[:nodes].empty?
-          if options[:task_options]['nodes']
-            raise Bolt::CLIError,
-                  "A plan's 'nodes' parameter may be specified using the --nodes option, but in that " \
-                  "case it must not be specified as a separate nodes=<value> parameter nor included " \
-                  "in the JSON data passed in the --params option"
-          end
-          options[:task_options]['nodes'] = options[:nodes].join(',')
-        end
-
-        params = options[:noop] ? options[:task_options].merge("_noop" => true) : options[:task_options]
-        plan_context = { plan_name: options[:object],
-                         params: params }
-        plan_context[:description] = options[:description] if options[:description]
-
-        executor = Bolt::Executor.new(config, @analytics, options[:noop], bundled_content: bundled_content)
-        executor.start_plan(plan_context)
-        result = pal.run_plan(options[:object], options[:task_options], executor, inventory, puppetdb_client)
-
-        # If a non-bolt exeception bubbles up the plan won't get finished
-        executor.finish_plan(result)
-        outputter.print_plan_result(result)
-        code = result.ok? ? 0 : 1
+      if options[:subcommand] == 'plan'
+        code = run_plan(options[:object], options[:task_options], options[:nodes], options)
+      elsif options[:subcommand] == 'puppetfile'
+        code = install_puppetfile(@config.puppetfile, @config.modulepath)
       else
-        executor = Bolt::Executor.new(config, @analytics, options[:noop], bundled_content: bundled_content)
+        executor = Bolt::Executor.new(config.concurrency, @analytics, options[:noop], bundled_content: bundled_content)
         targets = options[:targets]
 
         results = nil
@@ -281,7 +266,7 @@ module Bolt
           executor_opts = {}
           executor_opts['_description'] = options[:description] if options.key?(:description)
           results =
-            case options[:mode]
+            case options[:subcommand]
             when 'command'
               executor.run_command(targets, options[:object], executor_opts) do |event|
                 outputter.print_event(event)
@@ -330,6 +315,80 @@ module Bolt
       @analytics&.finish
     end
 
+    def show_task(task_name)
+      outputter.print_task_info(pal.get_task_info(task_name))
+    end
+
+    def list_tasks
+      outputter.print_table(pal.list_tasks)
+      outputter.print_message("\nUse `bolt task show <task-name>` to view "\
+                              "details and parameters for a specific task.")
+    end
+
+    def show_plan(plan_name)
+      outputter.print_plan_info(pal.get_plan_info(plan_name))
+    end
+
+    def list_plans
+      outputter.print_table(pal.list_plans)
+      outputter.print_message("\nUse `bolt plan show <plan-name>` to view "\
+                              "details and parameters for a specific plan.")
+    end
+
+    def run_plan(plan_name, plan_arguments, nodes, options)
+      unless nodes.empty?
+        if plan_arguments['nodes']
+          raise Bolt::CLIError,
+                "A plan's 'nodes' parameter may be specified using the --nodes option, but in that " \
+                "case it must not be specified as a separate nodes=<value> parameter nor included " \
+                "in the JSON data passed in the --params option"
+        end
+        plan_arguments['nodes'] = nodes.join(',')
+      end
+
+      params = options[:noop] ? plan_arguments.merge('_noop' => true) : plan_arguments
+      plan_context = { plan_name: plan_name,
+                       params: params }
+      plan_context[:description] = options[:description] if options[:description]
+
+      executor = Bolt::Executor.new(config.concurrency, @analytics, options[:noop], bundled_content: bundled_content)
+      executor.start_plan(plan_context)
+      result = pal.run_plan(plan_name, plan_arguments, executor, inventory, puppetdb_client)
+
+      # If a non-bolt exeception bubbles up the plan won't get finished
+      executor.finish_plan(result)
+      outputter.print_plan_result(result)
+      result.ok? ? 0 : 1
+    end
+
+    def install_puppetfile(puppetfile, modulepath)
+      if puppetfile.exist?
+        moduledir = modulepath.first.to_s
+        r10k_config = {
+          root: puppetfile.dirname.to_s,
+          puppetfile: puppetfile.to_s,
+          moduledir: moduledir
+        }
+        install_action = R10K::Action::Puppetfile::Install.new(r10k_config, nil)
+
+        # Override the r10k logger with a proxy to our own logger
+        R10K::Logging.instance_variable_set(:@outputter, Bolt::R10KLogProxy.new)
+
+        ok = install_action.call
+        outputter.print_puppetfile_result(ok, puppetfile, moduledir)
+
+        ok ? 0 : 1
+      else
+        raise Bolt::FileError.new("Could not find a Puppetfile at #{puppetfile}", puppetfile)
+      end
+    rescue R10K::Error => e
+      raise PuppetfileError, e
+    end
+
+    def pal
+      @pal ||= Bolt::PAL.new(config.modulepath, config.hiera_config, config.compile_concurrency)
+    end
+
     def validate_file(type, path)
       if path.nil?
         raise Bolt::CLIError, "A #{type} must be specified"
@@ -351,18 +410,20 @@ module Bolt
     end
 
     def outputter
-      @outputter ||= Bolt::Outputter.for_format(config[:format], config[:color], config[:trace])
+      @outputter ||= Bolt::Outputter.for_format(config.format, config.color, config.trace)
     end
 
     def bundled_content
-      default_content = Bolt::PAL.new(Bolt::Config.new)
-      plans = default_content.list_plans.each_with_object([]) do |iter, col|
-        col << iter&.first
-      end
-      tasks = default_content.list_tasks.each_with_object([]) do |iter, col|
-        col << iter&.first
+      if %w[plan task].include?(options[:subcommand])
+        default_content = Bolt::PAL.new([], nil)
+        plans = default_content.list_plans.each_with_object([]) do |iter, col|
+          col << iter&.first
+        end
+        tasks = default_content.list_tasks.each_with_object([]) do |iter, col|
+          col << iter&.first
+        end
+        plans.concat tasks
       end
-      plans.concat tasks
     end
   end
 end