bolt 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7f70a1d9878c8a40b79b597ed62e5c7307d200b
-  data.tar.gz: f8bdfadbfe729a572acd6f6feabfb3b334c1f16e
+  metadata.gz: 4d17e85d4ead68354a59253671eaa9246fcd9c25
+  data.tar.gz: e00bb08318f54e3d03cd1e144a646e9c4e7eb3fc
 SHA512:
-  metadata.gz: 68e190c03a5ad2be65fd0832dec9080aaf03de408514d575244997a96663f9f9bdc7ee1b0e18fa4fd35ff3a705fde3b99e40ed5213aa374fa8a359ef28f8a2bf
-  data.tar.gz: 14cc9838705602039e3fd902f229f25b48a96c9580f54efeeb624087debb8ffec0167b5288bcb23d4c7f0309505f39856a4eb37ce24c068fcccba3dc222247ca
+  metadata.gz: 0c8d07c175cda227ca2138956167fec92b403deeb967cdb1d83116f9012c13e9b6ba5d4a4bd2178a40cc04ee7153ebb59734263e2056d3054da5e89ede11bc4e
+  data.tar.gz: e750e86b36f107295719ae0f6b8340c0e216208ebf7c15bbf17f99ac5785895a1b556a3ce8aead3b267f90abd3256eb2afa0d8f8df7b365334af5caaf7a6379f

data/lib/bolt/cli.rb

@@ -6,6 +6,7 @@ require 'json'
 require 'bolt/node'
 require 'bolt/version'
 require 'bolt/executor'
+require 'bolt/outputter'
 require 'bolt/config'
 require 'io/console'
 
@@ -17,6 +18,12 @@ module Bolt
       super(msg)
       @error_code = error_code
     end
+
+    def to_json
+      { kind: "bolt/cli-error",
+        msg: message,
+        details: { error_code: @error_code } }.to_json
+    end
   end
 
   class CLIExit < StandardError; end
@@ -149,6 +156,17 @@ HELP
                 "Parameters to a task or plan") do |params|
           results[:task_options] = parse_params(params)
         end
+
+        results[:format] = 'human'
+        opts.on('--format FORMAT',
+                "Output format to use") do |format|
+          if %w[human json].include? format
+            results[:format] = format
+          else
+            raise ArgumentError "Unsupported format: #{format}"
+          end
+        end
+        results[:insecure] = false
         opts.on('-k', '--insecure',
                 "Whether to connect insecurely ") do |insecure|
           results[:insecure] = insecure
@@ -157,6 +175,23 @@ HELP
                 "Specify a default transport: #{TRANSPORTS.join(', ')}") do |t|
           options[:transport] = t
         end
+        opts.on('--run-as USER',
+                "User to run as using privilege escalation") do |user|
+          options[:run_as] = user
+        end
+        opts.on('--sudo [PROGRAM]',
+                "Program to execute for privilege escalation. " \
+                "Currently only sudo is supported.") do |program|
+          options[:sudo] = program || 'sudo'
+          if options[:sudo] != 'sudo'
+            raise Bolt::CLIError,
+                  "Only 'sudo' is supported for privilege escalation."
+          end
+        end
+        opts.on('--sudo-password [PASSWORD]',
+                'Password for privilege escalation') do |password|
+          options[:sudo_password] = password
+        end
         opts.on_tail('--[no-]tty',
                      "Request a pseudo TTY on nodes that support it") do |tty|
           results[:tty] = tty
@@ -202,6 +237,8 @@ HELP
         @config[:log_level] = Logger::INFO
       end
 
+      @config[:format] = options[:format]
+
       if options[:help]
         print_help(options[:mode])
         raise Bolt::CLIExit
@@ -327,7 +364,8 @@ HELP
     end
 
     def execute(options)
-      %i[concurrency user password tty insecure transport].each do |key|
+      %i[concurrency user password tty insecure transport
+         sudo sudo_password run_as].each do |key|
         config[key] = options[key]
       end
 
@@ -354,15 +392,23 @@ HELP
         nodes = executor.from_uris(options[:nodes])
 
         results = nil
+        outputter.print_head
+
         elapsed_time = Benchmark.realtime do
           results =
             case options[:mode]
             when 'command'
-              executor.run_command(nodes, options[:object])
+              executor.run_command(nodes, options[:object]) do |node, result|
+                outputter.print_result(node, result)
+              end
             when 'script'
               script = options[:object]
               validate_file('script', script)
-              executor.run_script(nodes, script, options[:leftovers])
+              executor.run_script(
+                nodes, script, options[:leftovers]
+              ) do |node, result|
+                outputter.print_result(node, result)
+              end
             when 'task'
               task_name = options[:object]
 
@@ -372,7 +418,9 @@ HELP
               input_method ||= 'both'
               executor.run_task(
                 nodes, path, input_method, options[:task_options]
-              )
+              ) do |node, result|
+                outputter.print_result(node, result)
+              end
             when 'file'
               src = options[:object]
               dest = options[:leftovers].first
@@ -381,46 +429,31 @@ HELP
                 raise Bolt::CLIError, "A destination path must be specified"
               end
               validate_file('source file', src)
-              executor.file_upload(nodes, src, dest)
+              executor.file_upload(nodes, src, dest) do |node, result|
+                outputter.print_result(node, result)
+              end
             end
         end
 
-        print_results(results, elapsed_time)
+        outputter.print_summary(results, elapsed_time)
       end
+    rescue Bolt::CLIError => e
+      outputter.fatal_error(e)
+      raise e
     end
 
     def execute_plan(executor, options)
+      # Plans return null here?
       result = Puppet.override(bolt_executor: executor) do
         run_plan(options[:object],
                  options[:task_options],
                  options[:modulepath])
       end
-      puts result
+      outputter.print_plan(result)
     rescue Puppet::Error
       raise Bolt::CLIError, "Exiting because of an error in Puppet code"
     end
 
-    def colorize(result, stream)
-      color = result.success? ? "\033[32m" : "\033[31m"
-      stream.print color if stream.isatty
-      yield
-      stream.print "\033[0m" if stream.isatty
-    end
-
-    def print_results(results, elapsed_time)
-      results.each_pair do |node, result|
-        colorize(result, $stdout) { $stdout.puts "#{node.host}:" }
-        $stdout.puts
-        $stdout.puts result.message
-        $stdout.puts
-      end
-
-      $stdout.puts format("Ran on %d node%s in %.2f seconds",
-                          results.size,
-                          results.size > 1 ? 's' : '',
-                          elapsed_time)
-    end
-
     def validate_file(type, path)
       if path.nil?
         raise Bolt::CLIError, "A #{type} must be specified"
@@ -441,6 +474,10 @@ HELP
       File.stat(path)
     end
 
+    def outputter
+      @outputter ||= Bolt::Outputter.for_format(@config[:format])
+    end
+
     def load_task_data(name, modulepath)
       module_name, file_name = name.split('::', 2)
       file_name ||= 'init'

data/lib/bolt/config.rb

@@ -1,14 +1,20 @@
 require 'logger'
 
 module Bolt
-  Config = Struct.new(:concurrency,
-                      :user,
-                      :password,
-                      :tty,
-                      :insecure,
-                      :transport,
-                      :log_level,
-                      :log_destination) do
+  Config = Struct.new(
+    :concurrency,
+    :format,
+    :insecure,
+    :log_destination,
+    :log_level,
+    :password,
+    :run_as,
+    :sudo,
+    :sudo_password,
+    :transport,
+    :tty,
+    :user
+  ) do
     DEFAULTS = {
       concurrency: 100,
       tty: false,
@@ -22,5 +28,9 @@ module Bolt
       super()
       DEFAULTS.merge(kwargs).each { |k, v| self[k] = v }
     end
+
+    def escalate?
+      sudo || run_as
+    end
   end
 end

data/lib/bolt/executor.rb

@@ -3,6 +3,7 @@ require 'concurrent'
 require 'bolt/result'
 require 'bolt/config'
 require 'bolt/formatter'
+require 'bolt/notifier'
 
 module Bolt
   class Executor
@@ -12,6 +13,7 @@ module Bolt
       @logger.progname = 'executor'
       @logger.level = config[:log_level]
       @logger.formatter = Bolt::Formatter.new
+      @notifier = Bolt::Notifier.new
     end
 
     def from_uris(nodes)
@@ -20,7 +22,7 @@ module Bolt
       end
     end
 
-    def on(nodes)
+    def on(nodes, callback = nil)
       results = Concurrent::Map.new
 
       poolsize = [nodes.length, @config[:concurrency]].min
@@ -33,7 +35,7 @@ module Bolt
 
       nodes.each { |node|
         pool.post do
-          results[node] =
+          result =
             begin
               node.connect
               yield node
@@ -45,34 +47,47 @@ module Bolt
             ensure
               node.disconnect
             end
+          results[node] = result
+          @notifier.notify(callback, node, result) if callback
+          result
         end
       }
       pool.shutdown
       pool.wait_for_termination
 
+      @notifier.shutdown
+
       results_to_hash(results)
     end
 
     def run_command(nodes, command)
-      on(nodes) do |node|
+      callback = block_given? ? Proc.new : nil
+
+      on(nodes, callback) do |node|
         node.run_command(command)
       end
     end
 
     def run_script(nodes, script, arguments)
-      on(nodes) do |node|
+      callback = block_given? ? Proc.new : nil
+
+      on(nodes, callback) do |node|
         node.run_script(script, arguments)
       end
     end
 
     def run_task(nodes, task, input_method, arguments)
-      on(nodes) do |node|
+      callback = block_given? ? Proc.new : nil
+
+      on(nodes, callback) do |node|
         node.run_task(task, input_method, arguments)
       end
     end
 
     def file_upload(nodes, source, destination)
-      on(nodes) do |node|
+      callback = block_given? ? Proc.new : nil
+
+      on(nodes, callback) do |node|
         node.upload(source, destination)
       end
     end

data/lib/bolt/node.rb

@@ -40,6 +40,9 @@ module Bolt
       @tty = config[:tty]
       @insecure = config[:insecure]
       @uri = uri
+      @sudo = config[:sudo]
+      @sudo_password = config[:sudo_password]
+      @run_as = config[:run_as]
 
       @logger = init_logger(config[:log_destination], config[:log_level])
       @transport_logger = init_logger(config[:log_destination], Logger::WARN)

data/lib/bolt/node/result.rb

@@ -38,6 +38,11 @@ module Bolt
       def exit_code
         0
       end
+
+      def ensure
+        yield
+        self
+      end
     end
 
     class Success < Result

data/lib/bolt/node/ssh.rb

@@ -54,9 +54,19 @@ module Bolt
       end
     end
 
-    def execute(command, options = {})
+    def execute(command, sudoable: false, **options)
       result_output = Bolt::Node::ResultOutput.new
       status = {}
+      use_sudo = sudoable && (@sudo || @run_as)
+      sudo_prompt = '[sudo] Bolt needs to run as another user, password: '
+      if use_sudo
+        user_clause = if @run_as
+                        "-u #{@run_as}"
+                      else
+                        ''
+                      end
+        command = "sudo -S #{user_clause} -p '#{sudo_prompt}' #{command}"
+      end
 
       @logger.debug { "Executing: #{command}" }
 
@@ -68,12 +78,22 @@ module Bolt
           raise "could not execute command: #{command.inspect}" unless success
 
           channel.on_data do |_, data|
-            result_output.stdout << data
+            if use_sudo && data == sudo_prompt
+              channel.send_data "#{@sudo_password}\n"
+              channel.wait
+            else
+              result_output.stdout << data
+            end
             @logger.debug { "stdout: #{data}" }
           end
 
           channel.on_extended_data do |_, _, data|
-            result_output.stderr << data
+            if use_sudo && data == sudo_prompt
+              channel.send_data "#{@sudo_password}\n"
+              channel.wait
+            else
+              result_output.stderr << data
+            end
             @logger.debug { "stderr: #{data}" }
           end
 
@@ -113,31 +133,66 @@ module Bolt
       Bolt::Node::ExceptionFailure.new(e)
     end
 
-    def with_remote_file(file)
-      remote_path = ''
-      dir = ''
-      result = nil
-
-      make_tempdir.then do |value|
-        dir = value
-        remote_path = "#{dir}/#{File.basename(file)}"
-        Bolt::Node::Success.new
-      end.then do
-        _upload(file, remote_path)
-      end.then do
+    def with_remote_tempdir
+      make_tempdir.then do |dir|
+        (yield dir).ensure do
+          execute("rm -rf '#{dir}'")
+        end
+      end
+    end
+
+    def with_remote_script(dir, file)
+      remote_path = "#{dir}/#{File.basename(file)}"
+      _upload(file, remote_path).then do
         execute("chmod u+x '#{remote_path}'")
       end.then do
-        result = yield remote_path
-      end.then do
-        execute("rm -f '#{remote_path}'")
+        yield remote_path
+      end
+    end
+
+    def with_remote_file(file)
+      with_remote_tempdir do |dir|
+        with_remote_script(dir, file) do |remote_path|
+          yield remote_path
+        end
+      end
+    end
+
+    def make_wrapper_stringio(task_path, stdin)
+      StringIO.new(<<-SCRIPT)
+#!/bin/sh
+'#{task_path}' <<EOF
+#{stdin}
+EOF
+SCRIPT
+    end
+
+    def with_task_wrapper(remote_task, dir, stdin)
+      wrapper = make_wrapper_stringio(remote_task, stdin)
+      command = "#{dir}/wrapper.sh"
+      _upload(wrapper, command).then do
+        execute("chmod u+x '#{command}'")
       end.then do
-        execute("rmdir '#{dir}'")
-        result
+        yield command
+      end
+    end
+
+    def with_remote_task(task_file, stdin)
+      with_remote_tempdir do |dir|
+        with_remote_script(dir, task_file) do |remote_task|
+          if stdin
+            with_task_wrapper(remote_task, dir, stdin) do |command|
+              yield command
+            end
+          else
+            yield remote_task
+          end
+        end
       end
     end
 
     def _run_command(command)
-      execute(command)
+      execute(command, sudoable: true)
     end
 
     def _run_script(script, arguments)
@@ -145,7 +200,8 @@ module Bolt
       @logger.debug { "arguments: #{arguments}" }
 
       with_remote_file(script) do |remote_path|
-        execute("'#{remote_path}' #{Shellwords.join(arguments)}")
+        execute("'#{remote_path}' #{Shellwords.join(arguments)}",
+                sudoable: true)
       end
     end
 
@@ -166,13 +222,13 @@ module Bolt
         end.join(' ')
       end
 
-      with_remote_file(task) do |remote_path|
+      with_remote_task(task, stdin) do |remote_path|
         command = if export_args.empty?
                     "'#{remote_path}'"
                   else
-                    "export #{export_args} && '#{remote_path}'"
+                    "#{export_args} '#{remote_path}'"
                   end
-        execute(command, stdin: stdin)
+        execute(command, sudoable: true)
       end
     end
   end