bolt 1.19.0 → 1.20.0

data/lib/bolt/outputter.rb

@@ -2,19 +2,20 @@
 
 module Bolt
   class Outputter
-    def self.for_format(format, color, trace)
+    def self.for_format(format, color, verbose, trace)
       case format
       when 'human'
-        Bolt::Outputter::Human.new(color, trace)
+        Bolt::Outputter::Human.new(color, verbose, trace)
       when 'json'
-        Bolt::Outputter::JSON.new(color, trace)
+        Bolt::Outputter::JSON.new(color, verbose, trace)
       when nil
         raise "Cannot use outputter before parsing."
       end
     end
 
-    def initialize(color, trace, stream = $stdout)
+    def initialize(color, verbose, trace, stream = $stdout)
       @color = color
+      @verbose = verbose
       @trace = trace
       @stream = stream
     end
@@ -23,3 +24,4 @@ end
 
 require 'bolt/outputter/human'
 require 'bolt/outputter/json'
+require 'bolt/outputter/logger'

data/lib/bolt/outputter/human.rb

@@ -11,6 +11,14 @@ module Bolt
 
       def print_head; end
 
+      def initialize(color, verbose, trace, stream = $stdout)
+        super
+        # Plans and without_default_logging() calls can both be nested, so we
+        # track each of them with a "stack" consisting of an integer.
+        @plan_depth = 0
+        @disable_depth = 0
+      end
+
       def colorize(color, string)
         if @color && @stream.isatty
           "\033[#{COLORS[color]}m#{string}\033[0m"
@@ -28,15 +36,37 @@ module Bolt
         string.sub(/\s\z/, '')
       end
 
-      def print_event(event)
+      def handle_event(event)
+        return unless enabled? || event[:type] == :enable_default_output
+
         case event[:type]
         when :node_start
-          print_start(event[:target])
+          print_start(event[:target]) if @verbose
         when :node_result
-          print_result(event[:result])
+          print_result(event[:result]) if @verbose
+        when :step_start
+          print_step_start(event) if plan_logging?
+        when :step_finish
+          print_step_finish(event) if plan_logging?
+        when :plan_start
+          print_plan_start(event)
+        when :plan_finish
+          print_plan_finish(event)
+        when :enable_default_output
+          @disable_depth -= 1
+        when :disable_default_output
+          @disable_depth += 1
         end
       end
 
+      def enabled?
+        @disable_depth == 0
+      end
+
+      def plan_logging?
+        @plan_depth > 0
+      end
+
       def print_start(target)
         @stream.puts(colorize(:green, "Started on #{target.host}..."))
       end
@@ -52,6 +82,15 @@ module Bolt
           @stream.puts(colorize(:red, remove_trail(indent(2, result.error_hash['msg']))))
         end
 
+        if result.is_a?(Bolt::ApplyResult) && @verbose
+          result.resource_logs.each do |log|
+            # Omit low-level info/debug messages
+            next if %w[info debug].include?(log['level'])
+            message = format_log(log)
+            @stream.puts(indent(2, message))
+          end
+        end
+
         if result.message
           @stream.puts(remove_trail(indent(2, result.message)))
         end
@@ -74,6 +113,52 @@ module Bolt
         end
       end
 
+      def format_log(log)
+        color = case log['level']
+                when 'warn'
+                  :yellow
+                when 'err'
+                  :red
+                end
+        source = "#{log['source']}: " if log['source']
+        message = "#{log['level'].capitalize}: #{source}#{log['message']}"
+        message = colorize(color, message) if color
+        message
+      end
+
+      def print_step_start(description:, targets:, **_kwargs)
+        target_str = if targets.length > 5
+                       "#{targets.count} targets"
+                     else
+                       targets.map(&:uri).join(', ')
+                     end
+        @stream.puts(colorize(:green, "Starting: #{description} on #{target_str}"))
+      end
+
+      def print_step_finish(description:, result:, duration:, **_kwargs)
+        failures = result.error_set.length
+        plural = failures == 1 ? '' : 's'
+        message = "Finished: #{description} with #{failures} failure#{plural} in #{duration.round(2)} sec"
+        @stream.puts(colorize(:green, message))
+      end
+
+      def print_plan_start(event)
+        @plan_depth += 1
+        # We use this event to both mark the start of a plan _and_ to enable
+        # plan logging for `apply`, so only log the message if we were called
+        # with a plan
+        if event[:plan]
+          @stream.puts(colorize(:green, "Starting: plan #{event[:plan]}"))
+        end
+      end
+
+      def print_plan_finish(event)
+        @plan_depth -= 1
+        plan = event[:plan]
+        duration = event[:duration]
+        @stream.puts(colorize(:green, "Finished: plan #{plan} in #{duration.round(2)} sec"))
+      end
+
       def print_summary(results, elapsed_time = nil)
         ok_set = results.ok_set
         unless ok_set.empty?
@@ -222,9 +307,8 @@ module Bolt
       end
 
       # @param [Bolt::ResultSet] apply_result A ResultSet object representing the result of a `bolt apply`
-      def print_apply_result(apply_result)
-        apply_result.each { |result| print_result(result) }
-        print_summary(apply_result)
+      def print_apply_result(apply_result, elapsed_time)
+        print_summary(apply_result, elapsed_time)
       end
 
       # @param [Bolt::PlanResult] plan_result A PlanResult object

data/lib/bolt/outputter/json.rb

@@ -3,11 +3,11 @@
 module Bolt
   class Outputter
     class JSON < Bolt::Outputter
-      def initialize(color, trace, stream = $stdout)
+      def initialize(color, verbose, trace, stream = $stdout)
+        super
         @items_open = false
         @object_open = false
         @preceding_item = false
-        super(color, trace, stream)
       end
 
       def print_head
@@ -17,7 +17,7 @@ module Bolt
         @object_open = true
       end
 
-      def print_event(event)
+      def handle_event(event)
         case event[:type]
         when :node_result
           print_result(event[:result])
@@ -72,7 +72,7 @@ module Bolt
         print_table('plans' => plans, 'modulepath' => modulepath)
       end
 
-      def print_apply_result(apply_result)
+      def print_apply_result(apply_result, _elapsed_time)
         @stream.puts apply_result.to_json
       end
 

data/lib/bolt/outputter/logger.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'bolt/pal'
+
+module Bolt
+  class Outputter
+    class Logger < Bolt::Outputter
+      def initialize(verbose, trace)
+        super(false, verbose, trace)
+        @logger = Logging.logger[self]
+      end
+
+      def handle_event(event)
+        case event[:type]
+        when :step_start
+          log_step_start(event)
+        when :step_finish
+          log_step_finish(event)
+        when :plan_start
+          log_plan_start(event)
+        when :plan_finish
+          log_plan_finish(event)
+        end
+      end
+
+      def log_step_start(description:, targets:, **_kwargs)
+        target_str = if targets.length > 5
+                       "#{targets.count} targets"
+                     else
+                       targets.map(&:uri).join(', ')
+                     end
+        @logger.info("Starting: #{description} on #{target_str}")
+      end
+
+      def log_step_finish(description:, result:, duration:, **_kwargs)
+        failures = result.error_set.length
+        plural = failures == 1 ? '' : 's'
+        @logger.info("Finished: #{description} with #{failures} failure#{plural} in #{duration.round(2)} sec")
+      end
+
+      def log_plan_start(event)
+        plan = event[:plan]
+        @logger.notice("Starting: plan #{plan}")
+      end
+
+      def log_plan_finish(event)
+        plan = event[:plan]
+        duration = event[:duration]
+        @logger.notice("Finished: plan #{plan} in #{duration.round(2)} sec")
+      end
+    end
+  end
+end

data/lib/bolt/pal.rb

@@ -333,10 +333,10 @@ module Bolt
       end
     end
 
-    def run_task(task_name, targets, params, executor, inventory, description = nil, &eventblock)
+    def run_task(task_name, targets, params, executor, inventory, description = nil)
       in_task_compiler(executor, inventory) do |compiler|
-        params = params.merge('_bolt_api_call' => true)
-        compiler.call_function('run_task', task_name, targets, description, params, &eventblock)
+        params = params.merge('_bolt_api_call' => true, '_catch_errors' => true)
+        compiler.call_function('run_task', task_name, targets, description, params)
       end
     end
 

data/lib/bolt/pal/yaml_plan/step.rb

@@ -77,7 +77,7 @@ module Bolt
             # We have to do a little extra parsing here, since we only need
             # with() for eval blocks
             code = Bolt::Util.to_code(body['eval'])
-            if @name && code.include?("\n")
+            if @name && code.lines.count > 1
               # A little indented niceness
               indented = code.gsub(/\n/, "\n    ").chomp("  ")
               result << "with() || {\n    #{indented}}"

data/lib/bolt/plugin.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require 'bolt/plugin/puppetdb'
+require 'bolt/plugin/terraform'
 
 module Bolt
   class Plugin
     def self.setup(config, pdb_client)
       plugins = new(config)
       plugins.add_plugin(Bolt::Plugin::Puppetdb.new(pdb_client))
+      plugins.add_plugin(Bolt::Plugin::Terraform.new)
       plugins
     end
 

data/lib/bolt/plugin/terraform.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Bolt
+  class Plugin
+    class Terraform
+      def initialize
+        @logger = Logging.logger[self]
+      end
+
+      def name
+        'terraform'
+      end
+
+      def hooks
+        ['lookup_targets']
+      end
+
+      def warn_missing_property(name, property)
+        @logger.warn("Could not find property #{property} of terraform resource #{name}")
+      end
+
+      def lookup_targets(opts)
+        state = load_statefile(opts)
+
+        resources = state.fetch('modules', {}).flat_map do |mod|
+          mod.fetch('resources', {}).map do |name, resource|
+            [name, resource.dig('primary', 'attributes')]
+          end
+        end
+
+        regex = Regexp.new(opts['resource_type'])
+
+        resources.select do |name, _resource|
+          name.match?(regex)
+        end.map do |name, resource|
+          unless resource.key?(opts['uri'])
+            warn_missing_property(name, opts['uri'])
+            next
+          end
+
+          target = { 'uri' => resource[opts['uri']] }
+          if opts.key?('name')
+            if resource.key?(opts['name'])
+              target['name'] = resource[opts['name']]
+            else
+              warn_missing_property(name, opts['name'])
+            end
+          end
+          if opts.key?('config')
+            target['config'] = resolve_config(name, resource, opts['config'])
+          end
+          target
+        end.compact
+      end
+
+      def load_statefile(opts)
+        dir = opts['dir']
+        filename = opts.fetch('statefile', 'terraform.tfstate')
+        statefile = File.expand_path(File.join(dir, filename))
+
+        JSON.parse(File.read(statefile))
+      rescue StandardError => e
+        raise Bolt::FileError.new("Could not load Terraform state file #{filename}: #{e}", filename)
+      end
+
+      def resolve_config(name, resource, config_template)
+        Bolt::Util.walk_vals(config_template) do |value|
+          if value.is_a?(String)
+            if resource.key?(value)
+              resource[value]
+            else
+              warn_missing_property(name, value)
+              nil
+            end
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/result.rb

@@ -5,7 +5,7 @@ require 'bolt/error'
 
 module Bolt
   class Result
-    attr_reader :target, :value, :type, :object
+    attr_reader :target, :value, :action, :object
 
     def self.from_exception(target, exception)
       @exception = exception
@@ -23,7 +23,7 @@ module Bolt
       Result.new(target, error: error)
     end
 
-    def self.for_command(target, stdout, stderr, exit_code, type, command)
+    def self.for_command(target, stdout, stderr, exit_code, action, command)
       value = {
         'stdout' => stdout,
         'stderr' => stderr,
@@ -37,7 +37,7 @@ module Bolt
           'details' => { 'exit_code' => exit_code }
         }
       end
-      new(target, value: value, type: type, object: command)
+      new(target, value: value, action: action, object: command)
     end
 
     def self.for_task(target, stdout, stderr, exit_code, task)
@@ -61,11 +61,11 @@ module Bolt
                             'msg' => msg,
                             'details' => { 'exit_code' => exit_code } }
       end
-      new(target, value: value, type: 'task', object: task)
+      new(target, value: value, action: 'task', object: task)
     end
 
     def self.for_upload(target, source, destination)
-      new(target, message: "Uploaded '#{source}' to '#{target.host}:#{destination}'", type: 'upload', object: source)
+      new(target, message: "Uploaded '#{source}' to '#{target.host}:#{destination}'", action: 'upload', object: source)
     end
 
     # Satisfies the Puppet datatypes API
@@ -73,10 +73,10 @@ module Bolt
       new(target, value: value)
     end
 
-    def initialize(target, error: nil, message: nil, value: nil, type: nil, object: nil)
+    def initialize(target, error: nil, message: nil, value: nil, action: nil, object: nil)
       @target = target
       @value = value || {}
-      @type = type
+      @action = action
       @object = object
       @value_set = !value.nil?
       if error && !error.is_a?(Hash)
@@ -94,7 +94,7 @@ module Bolt
       # DEPRECATION: node in status hashes is deprecated and should be removed in 2.0
       { node: @target.name,
         target: @target.name,
-        type: type,
+        action: action,
         object: object,
         status: ok? ? 'success' : 'failure',
         result: @value }
@@ -128,6 +128,10 @@ module Bolt
       to_json
     end
 
+    def to_data
+      Bolt::Util.walk_keys(status_hash, &:to_s)
+    end
+
     def ok?
       error_hash.nil?
     end

data/lib/bolt/result_set.rb

@@ -90,6 +90,10 @@ module Bolt
       @results.map(&:status_hash).to_json(opts)
     end
 
+    def to_data
+      @results.map(&:to_data)
+    end
+
     def to_s
       to_json
     end