bolt 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6515bd6a3cf63131c23e0809aa98a057030977a3
-  data.tar.gz: eee81f558aefb21e761082b04bd73bd631e6685d
+  metadata.gz: aa5ef349a62f61714a7ae4b664febe0a794a1acf
+  data.tar.gz: bd71a0e1d122717a98f35ec882fd90bc885067f4
 SHA512:
-  metadata.gz: 5598b32bf144d8fe0a2cc0601f5ec136235646b182c1a4dc9c4f00aef467f6ea88cdcfcdec25c4fbf88241aa3485d5e9317f34a5d44d8a982f81725678ce8f1b
-  data.tar.gz: 2aac3a8c35530eecaf1e57e206d24f8ae3c0f4eb0f53199ff4d14c491cbef873a8b0791843242fb5ff5890393356da0f0f1235b815d093f075c31938cf1d2e4d
+  metadata.gz: ae08cc350289783f725460ada932ccda8431ccc33ed71c2cbd2680e0d2b125e41b0abe45acba8c7cf9170832afca19bd87bb5ce99d97f5afa9617ba73751e54a
+  data.tar.gz: 7cf3ed3887d53350ca23e28ff45ce890037593204eb68532aa8e6d9c0a842918513ff6be014d2379fe2f84cfe22caaff59913335386c5ec2e86a4a6c4fae3ece

data/exe/bolt

@@ -6,9 +6,10 @@ require 'bolt/cli'
 cli = Bolt::CLI.new(ARGV)
 begin
   opts = cli.parse
-  cli.execute(opts)
+  exitcode = cli.execute(opts)
+  exit exitcode
 rescue Bolt::CLIExit
   exit
-rescue Bolt::CLIError => e
+rescue Bolt::Error => e
   exit e.error_code
 end

data/lib/bolt/cli.rb

@@ -1,23 +1,23 @@
 require 'uri'
 require 'optparse'
 require 'benchmark'
-require 'bolt/logger'
 require 'json'
+require 'logging'
+require 'bolt/logger'
 require 'bolt/node'
 require 'bolt/version'
 require 'bolt/error'
 require 'bolt/executor'
+require 'bolt/target'
 require 'bolt/outputter'
 require 'bolt/config'
 require 'io/console'
 
 module Bolt
   class CLIError < Bolt::Error
-    attr_reader :error_code
-
-    def initialize(msg, error_code: 1)
+    def initialize(msg)
       super(msg, "bolt/cli-error")
-      @error_code = error_code
+      @error_code = error_code if error_code
     end
   end
 
@@ -103,30 +103,37 @@ HELP
     attr_accessor :options
 
     def initialize(argv)
+      Bolt::Logger.initialize_logging
       @argv    = argv
       @options = {
         nodes: []
       }
       @config = Bolt::Config.new
+
+      # parse mode and object, use COMMANDS as a whitelist
+      @options[:mode] = argv[0] if COMMANDS.keys.any? { |mode| argv[0] == mode }
+      @options[:object] = argv[1] if COMMANDS.values.flatten.uniq.any? { |object| argv[1] == object }
       @parser = create_option_parser(@options)
+      @logger = Logging.logger[self]
     end
 
     def create_option_parser(results)
-      OptionParser.new('') do |opts|
-        opts.on(
-          '-n', '--nodes NODES',
-          'Node(s) to connect to in URI format [protocol://]host[:port]',
-          'Eg. --nodes bolt.puppet.com',
-          'Eg. --nodes localhost,ssh://nix.com:2222,winrm://windows.puppet.com',
-          "\n",
-          '* NODES can either be comma-separated, \'@<file>\' to read',
-          '* nodes from a file, or \'-\' to read from stdin',
-          '* Windows nodes must specify protocol with winrm://',
-          '* protocol is `ssh` by default, may be `ssh` or `winrm`',
-          '* port is `22` by default for SSH, `5985` for winrm (Optional)'
-        ) do |nodes|
-          results[:nodes] += parse_nodes(nodes)
-          results[:nodes].uniq!
+      parser = OptionParser.new('') do |opts|
+        unless results[:mode] == 'plan'
+          opts.on('-n', '--nodes NODES',
+                  'Node(s) to connect to in URI format [protocol://]host[:port] (Optional)',
+                  'Eg. --nodes bolt.puppet.com',
+                  'Eg. --nodes localhost,ssh://nix.com:2222,winrm://windows.puppet.com',
+                  "\n",
+                  '* NODES can either be comma-separated, \'@<file>\' to read',
+                  '* nodes from a file, or \'-\' to read from stdin',
+                  '* Windows nodes must specify protocol with winrm://',
+                  '* protocol is `ssh` by default, may be `ssh` or `winrm`',
+                  '* port defaults to `22` for SSH',
+                  '* port defaults to `5985` or `5986` for WinRM, based on the --insecure setting') do |nodes|
+            results[:nodes] += parse_nodes(nodes)
+            results[:nodes].uniq!
+          end
         end
         opts.on('-u', '--user USER',
                 "User to authenticate as (Optional)") do |user|
@@ -148,7 +155,7 @@ HELP
           results[:key] = key
         end
         opts.on('--tmpdir DIR',
-                "The directory to upload and execute temporary files on the target(Optional)") do |tmpdir|
+                "The directory to upload and execute temporary files on the target (Optional)") do |tmpdir|
           results[:tmpdir] = tmpdir
         end
         opts.on('-c', '--concurrency CONCURRENCY', Integer,
@@ -222,6 +229,22 @@ HELP
           raise Bolt::CLIExit
         end
       end
+
+      parser.banner = case results[:mode]
+                      when "plan"
+                        PLAN_HELP
+                      when "command"
+                        COMMAND_HELP
+                      when "script"
+                        SCRIPT_HELP
+                      when "task"
+                        TASK_HELP
+                      when "file"
+                        FILE_HELP
+                      else
+                        BANNER
+                      end
+      parser
     end
 
     def parse
@@ -238,18 +261,21 @@ HELP
 
       if options[:mode] == 'help'
         options[:help] = true
+
+        # regenerate options parser with new mode
         options[:mode] = remaining.shift
+        @parser = create_option_parser(options)
       end
 
       if options[:help]
-        print_help(options[:mode])
+        puts parser.help
         raise Bolt::CLIExit
       end
 
       @config.load_file(options[:configfile])
       @config.update_from_cli(options)
-      Logger.configure(@config)
       @config.validate
+      Logging.logger[:root].level = @config[:log_level] || :notice
 
       # This section handles parsing non-flag options which are
       # mode specific rather then part of the config
@@ -277,27 +303,9 @@ HELP
       raise e
     end
 
-    def print_help(mode)
-      parser.banner = case mode
-                      when 'task'
-                        TASK_HELP
-                      when 'command'
-                        COMMAND_HELP
-                      when 'script'
-                        SCRIPT_HELP
-                      when 'file'
-                        FILE_HELP
-                      when 'plan'
-                        PLAN_HELP
-                      else
-                        BANNER
-                      end
-      puts parser.help
-    end
-
     def parse_nodes(nodes)
       list = get_arg_input(nodes)
-      list.split(/[[:space:],]+/).reject(&:empty?).uniq
+      Target.parse_urls(list)
     end
 
     def parse_params(params)
@@ -380,7 +388,7 @@ HELP
       yield
     rescue OptionParser::MissingArgument => e
       raise Bolt::CLIError, "Option '#{e.args.first}' needs a parameter"
-    rescue OptionParser::InvalidOption => e
+    rescue OptionParser::InvalidOption, OptionParser::AmbiguousOption => e
       raise Bolt::CLIError, "Unknown argument '#{e.args.first}'"
     end
 
@@ -392,18 +400,17 @@ HELP
           raise Bolt::CLIError, "Puppet must be installed to execute tasks"
         end
 
+        # Now that puppet is loaded we can include puppet mixins in data types
+        Bolt::ResultSet.include_iterable
+
         Puppet::Util::Log.newdestination(:console)
-        Puppet[:log_level] = if @config[:log_level] == Logger::DEBUG
+        Puppet[:log_level] = if @config[:log_level] == :debug
                                'debug'
                              else
                                'notice'
                              end
       end
 
-      # ExecutionResult loaded here so that it can get puppet features if
-      # puppet is present
-      require 'bolt/execution_result'
-
       if options[:action] == 'show'
         if options[:mode] == 'task'
           if options[:object]
@@ -417,15 +424,16 @@ HELP
         elsif options[:mode] == 'plan'
           outputter.print_table(list_plans)
         end
-        return
+        return 0
       end
 
       if options[:mode] == 'plan'
         executor = Bolt::Executor.new(@config, options[:noop], true)
         execute_plan(executor, options)
+        code = 0
       else
         executor = Bolt::Executor.new(@config, options[:noop])
-        nodes = executor.from_uris(options[:nodes])
+        targets = options[:nodes]
 
         results = nil
         outputter.print_head
@@ -434,20 +442,20 @@ HELP
           results =
             case options[:mode]
             when 'command'
-              executor.run_command(nodes, options[:object]) do |node, event|
-                outputter.print_event(node, event)
+              executor.run_command(targets, options[:object]) do |event|
+                outputter.print_event(event)
               end
             when 'script'
               script = options[:object]
               validate_file('script', script)
               executor.run_script(
-                nodes, script, options[:leftovers]
-              ) do |node, event|
-                outputter.print_event(node, event)
+                targets, script, options[:leftovers]
+              ) do |event|
+                outputter.print_event(event)
               end
             when 'task'
-              execute_task(executor, options) do |node, event|
-                outputter.print_event(node, event)
+              execute_task(executor, options) do |event|
+                outputter.print_event(event)
               end
             when 'file'
               src = options[:object]
@@ -457,15 +465,17 @@ HELP
                 raise Bolt::CLIError, "A destination path must be specified"
               end
               validate_file('source file', src)
-              executor.file_upload(nodes, src, dest) do |node, event|
-                outputter.print_event(node, event)
+              executor.file_upload(targets, src, dest) do |event|
+                outputter.print_event(event)
               end
             end
         end
 
         outputter.print_summary(results, elapsed_time)
+        code = results.ok ? 0 : 2
       end
-    rescue Bolt::CLIError => e
+      code
+    rescue Bolt::Error => e
       outputter.fatal_error(e)
       raise e
     end
@@ -516,8 +526,9 @@ HELP
       @outputter ||= Bolt::Outputter.for_format(@config[:format])
     end
 
-    # Runs a block in a PAL script compiler configured for Bolt.
-    # Catches exceptions thrown by the block and re-raises them as Bolt::CLIError.
+    # Runs a block in a PAL script compiler configured for Bolt.  Catches
+    # exceptions thrown by the block and re-raises them ensuring they are
+    # Bolt::Errors since the script compiler block will squash all exceptions.
     def in_bolt_compiler(opts = [])
       Puppet.initialize_settings(opts)
       r = Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + @config[:modulepath], facts: {}) do |pal|
@@ -525,14 +536,33 @@ HELP
           begin
             yield compiler
           rescue Puppet::PreformattedError => err
-            err.cause
+            # Puppet sometimes rescues exceptions notes the location and reraises
+            # For now return the original error. Exception cause support was added in Ruby 2.1
+            # so we fall back to reporting the error we got for Ruby 2.0.
+            if err.respond_to?(:cause) && err.cause
+              if err.cause.is_a? Bolt::Error
+                err.cause
+              else
+                e = Bolt::CLIError.new(err.cause.message)
+                e.set_backtrace(err.cause.backtrace)
+                e
+              end
+            else
+              e = Bolt::CLIError.new(err.message)
+              e.set_backtrace(err.backtrace)
+              e
+            end
           rescue StandardError => err
-            err
+            e = Bolt::CLIError.new(err.message)
+            e.set_backtrace(err.backtrace)
+            e
           end
         end
       end
 
-      raise Bolt::CLIError, r.message if r.is_a? StandardError
+      if r.is_a? StandardError
+        raise r
+      end
       r
     end
 
@@ -560,30 +590,10 @@ HELP
       task.task_hash
     end
 
-    def run_task(name, nodes, args, &block)
+    def run_task(name, targets, args, &block)
+      args = args.merge('_catch_errors' => true)
       in_bolt_compiler do |compiler|
-        compiler.call_function('run_task', name, nodes, args, &block)
-      end
-    end
-
-    # Expects to be called with a configured Puppet compiler or error.instance? will fail
-    def unwrap_execution_result(result)
-      if result.instance_of? Bolt::ExecutionResult
-        result.iterator.map do |node, output|
-          if output.is_a?(Puppet::DataTypes::Error)
-            # Get the original error hash used to initialize the Error type object.
-            result = output.partial_result || {}
-            result[:_error] = { msg: output.message,
-                                kind: output.kind,
-                                details: output.details,
-                                issue_code: output.issue_code }
-            { node: node, status: 'failed', result: result }
-          else
-            { node: node, status: 'finished', result: output }
-          end
-        end
-      else
-        result
+        compiler.call_function('run_task', name, targets, args, &block)
       end
     end
 
@@ -594,10 +604,7 @@ HELP
           cli << "--#{setting}" << dir
         end
         in_bolt_compiler(cli) do |compiler|
-          result = compiler.call_function('run_plan', plan, args)
-          # Querying ExecutionResult for failures currently requires a script compiler.
-          # Convert from an ExecutionResult to structured output that we can print.
-          unwrap_execution_result(result)
+          compiler.call_function('run_plan', plan, args)
         end
       end
     end

data/lib/bolt/config.rb

@@ -1,6 +1,6 @@
-require 'bolt/logger'
 require 'yaml'
 require 'bolt/cli'
+require 'logging'
 
 module Bolt
   Config = Struct.new(
@@ -33,6 +33,7 @@ module Bolt
 
     def initialize(**kwargs)
       super()
+      @logger = Logging.logger[self]
       DEFAULTS.merge(kwargs).each { |k, v| self[k] = v }
 
       self[:transports] ||= {}
@@ -58,8 +59,7 @@ module Bolt
       if path.nil?
         found_default = default_paths.select { |p| File.exist?(p) }
         if found_default.size > 1
-          logger = Logger.get_logger
-          logger.warn "Config files found at #{found_default.join(', ')}, using the first"
+          @logger.warn "Config files found at #{found_default.join(', ')}, using the first"
         end
         # Use first found, fall back to first default and try to load even if it didn't exist
         path = found_default.first || default_paths.first
@@ -161,9 +161,9 @@ module Bolt
       end
 
       if options[:debug]
-        self[:log_level] = Logger::DEBUG
+        self[:log_level] = :debug
       elsif options[:verbose]
-        self[:log_level] = Logger::INFO
+        self[:log_level] = :info
       end
 
       TRANSPORT_OPTIONS.each do |key|
@@ -184,9 +184,8 @@ module Bolt
       end
 
       if self[:transports][:ssh][:sudo_password] && self[:transports][:ssh][:run_as].nil?
-        logger = Logger.get_logger
-        logger.warn("--sudo-password will not be used without specifying a " \
-                    "user to escalate to with --run-as")
+        @logger.warn("--sudo-password will not be used without specifying a " \
+                     "user to escalate to with --run-as")
       end
 
       self[:transports].each_value do |v|

data/lib/bolt/error.rb

@@ -1,12 +1,13 @@
 module Bolt
   class Error < RuntimeError
-    attr_reader :kind, :details, :issue_code
+    attr_reader :kind, :details, :issue_code, :error_code
 
     def initialize(msg, kind, details = nil, issue_code = nil)
       super(msg)
       @kind = kind
       @issue_code = issue_code
       @details = details || {}
+      @error_code ||= 1
     end
 
     def msg
@@ -21,8 +22,24 @@ module Bolt
       h
     end
 
-    def to_json
-      to_h.to_json
+    def to_json(opts = nil)
+      to_h.to_json(opts)
+    end
+  end
+
+  class RunFailure < Error
+    attr_reader :resultset
+
+    def initialize(resultset, action, object)
+      details = {
+        action: action,
+        object: object,
+        failed_targets: resultset.error_set.names
+      }
+      message = "Plan aborted: #{action} '#{object}' failed on #{details[:failed_targets].length} nodes"
+      super(message, 'bolt/run-failure', details)
+      @resultset = resultset
+      @error_code = 2
     end
   end
 end