mux_tf 0.2.4 → 0.3.0

data/lib/mux_tf/cli/plan_summary.rb

@@ -14,271 +14,45 @@ module MuxTf
             hierarchy: false
           }
 
-          args = OptionParser.new do |opts|
-            opts.on('-i') do |v|
+          args = OptionParser.new { |opts|
+            opts.on("-i") do |v|
               options[:interactive] = v
             end
-            opts.on('-h') do |v|
+            opts.on("-h") do |v|
               options[:hierarchy] = v
             end
-          end.parse!(args)
+          }.parse!(args)
 
           if options[:interactive]
-            raise 'must specify plan file in interactive mode' if args[0].blank?
+            raise "must specify plan file in interactive mode" if args[0].blank?
           end
 
-          data = if args[0]
-                   load_summary_from_file(args[0])
-                 else
-                   JSON.parse(STDIN.read)
-          end
-
-          parts = []
-
-          data['resource_changes'].each do |v|
-            next unless v['change']
-
-            case v['change']['actions']
-            when ['no-op']
-              # do nothing
-            when ['create']
-              parts << {
-                action: 'create',
-                address: v['address'],
-                deps: find_deps(data, v['address'])
-              }
-            when ['update']
-              parts << {
-                action: 'update',
-                address: v['address'],
-                deps: find_deps(data, v['address'])
-              }
-            when ['delete']
-              parts << {
-                action: 'delete',
-                address: v['address'],
-                deps: find_deps(data, v['address'])
-              }
-            when %w[delete create]
-              parts << {
-                action: 'replace',
-                address: v['address'],
-                deps: find_deps(data, v['address'])
-              }
-            when ['read']
-              parts << {
-                action: 'read',
-                address: v['address'],
-                deps: find_deps(data, v['address'])
-              }
-            else
-              puts "[??] #{v['address']}"
-              puts "UNKNOWN ACTIONS: #{v['change']['actions'].inspect}"
-              puts 'TODO: update plan_summary to support this!'
-            end
-          end
-
-          prune_unchanged_deps(parts)
-
-          if options[:interactive]
-            run_interactive(parts, args[0])
+          plan = if args[0]
+            PlanSummaryHandler.from_file(args[0])
           else
-            if options[:hierarchy]
-              print_nested(parts)
-            else
-              print_flat(parts)
-            end
-            print_summary(parts)
-          end
-        end
-
-        def load_summary_from_file(file)
-          if File.exist?("#{file}.json") && File.mtime("#{file}.json").to_f >= File.mtime(file).to_f
-            JSON.parse(File.read("#{file}.json"))
-          else
-            puts 'Analyzing changes ...'
-            result = tf_show(file, json: true)
-            data = result.parsed_output
-            File.open("#{file}.json", 'w') { |fh| fh.write(JSON.dump(data)) }
-            data
-          end
-        end
-
-        def print_summary(parts)
-          summary = {}
-          parts.each do |part|
-            summary[part[:action]] ||= 0
-            summary[part[:action]] += 1
-          end
-          pieces = summary.map do |k, v|
-            color = color_for_action(k)
-            "#{Paint[v, :yellow]} to #{Paint[k, color]}"
+            PlanSummaryHandler.from_data(JSON.parse(STDIN.read))
           end
 
-          puts
-          puts "Plan Summary: #{pieces.join(Paint[', ', :gray])}"
-        end
-
-        def print_flat(parts)
-          parts.each do |part|
-            puts "[#{format_action(part[:action])}] #{format_address(part[:address])}"
-          end
-        end
-
-        def run_interactive(parts, _plan_name)
-          prompt = TTY::Prompt.new
-          result = prompt.multi_select('Update resources:', per_page: 99, echo: false) do |menu|
-            parts.each do |part|
-              label = "[#{format_action(part[:action])}] #{format_address(part[:address])}"
-              menu.choice label, part[:address]
+          if options[:interactive]
+            abort_message = catch :abort do
+              plan.run_interactive
             end
-          end
-
-          if !result.empty?
-            log 'Re-running apply with the selected resources ...'
-            status = tf_apply(targets: result)
-            unless status.success?
-              log Paint["Failed! (#{status.status})", :red]
-              exit status.status
+            if abort_message
+              log Paint["Aborted: #{abort_message}", :red]
             end
           else
-            raise 'nothing selected'
-          end
-        end
-
-        def print_nested(parts)
-          parts = parts.deep_dup
-          until parts.empty?
-            part = parts.shift
-            if part[:deps] == []
-              indent = if part[:met_deps] && !part[:met_deps].empty?
-                         '  '
-                       else
-                         ''
-              end
-              message = "[#{format_action(part[:action])}]#{indent} #{format_address(part[:address])}"
-              if part[:met_deps]
-                message += " - (needs: #{part[:met_deps].join(', ')})"
-              end
-              puts message
-              parts.each do |ipart|
-                d = ipart[:deps].delete(part[:address])
-                if d
-                  ipart[:met_deps] ||= []
-                  ipart[:met_deps] << d
-                end
+            if options[:hierarchy]
+              plan.nested_summary.each do |line|
+                puts line
               end
             else
-              parts.unshift part
-            end
-          end
-        end
-
-        def prune_unchanged_deps(parts)
-          valid_addresses = parts.map { |part| part[:address] }
-
-          parts.each do |part|
-            part[:deps].select! { |dep| valid_addresses.include?(dep) }
-          end
-        end
-
-        def find_config(module_root, module_name, address, parent_address)
-          module_info = if parent_address.empty?
-                          module_root[module_name]
-                        elsif module_root && module_root[module_name]
-                          module_root[module_name]['module']
-                        else
-                          {}
-          end
-
-          if m = address.match(/^module\.([^.]+)\./)
-            find_config(module_info['module_calls'], m[1], m.post_match, parent_address + ["module.#{m[1]}"])
-          else
-            if module_info['resources']
-              resource = module_info['resources'].find do |resource|
-                address == resource['address']
+              plan.flat_summary.each do |line|
+                puts line
               end
             end
-            [resource, parent_address]
-          end
-        end
-
-        def find_deps(data, address)
-          result = []
-
-          full_address = address
-          m = address.match(/\[(.+)\]$/)
-          if m
-            address = m.pre_match
-            index = m[1][0] == '"' ? m[1].gsub(/^"(.+)"$/, '\1') : m[1].to_i
-          end
-
-          if data['prior_state']['values']['root_module']['resources']
-            resource = data['prior_state']['values']['root_module']['resources'].find do |resource|
-              address == resource['address'] && index == resource['index']
-            end
-          end
-
-          result += resource['depends_on'] if resource && resource['depends_on']
-
-          resource, parent_address = find_config(data['configuration'], 'root_module', address, [])
-          if resource
-            deps = []
-            resource['expressions'].each do |_k, v|
-              deps << v['references'] if v.is_a?(Hash) && v['references']
-            end
-            result += deps.map { |s| (parent_address + [s]).join('.') }
-          end
-
-          result
-        end
-
-        def color_for_action(action)
-          case action
-          when 'create'
-            :green
-          when 'update'
-            :yellow
-          when 'delete'
-            :red
-          when 'replace'
-            :red
-          when 'read'
-            :cyan
-          else
-            :reset
-          end
-        end
-
-        def symbol_for_action(action)
-          case action
-          when 'create'
-            '+'
-          when 'update'
-            '~'
-          when 'delete'
-            '-'
-          when 'replace'
-            '±'
-          when 'read'
-            '>'
-          else
-            action
-          end
-        end
-
-        def format_action(action)
-          color = color_for_action(action)
-          symbol = symbol_for_action(action)
-          Paint[symbol, color]
-        end
-
-        def format_address(address)
-          parts = address.split('.')
-          parts.each_with_index do |part, index|
-            parts[index] = Paint[part, :cyan] if index.odd?
+            puts
+            puts plan.summary
           end
-          parts.join('.')
         end
       end
     end

data/lib/mux_tf/plan_formatter.rb

@@ -30,7 +30,7 @@ module MuxTf
 
         parser.state(:plan_error, /^Error: /, %i[refreshing refresh_done])
 
-        status = tf_plan(out: filename, detailed_exitcode: true, compact_warnings: true) do |raw_line|
+        status = tf_plan(out: filename, detailed_exitcode: true, compact_warnings: true) { |raw_line|
           plan_output << raw_line
           parser.parse(raw_line.rstrip) do |state, line|
             case state
@@ -42,19 +42,19 @@ module MuxTf
               end
             when :info
               if /Acquiring state lock. This may take a few moments.../.match?(line)
-                log 'Acquiring state lock ...', depth: 2
+                log "Acquiring state lock ...", depth: 2
               else
                 p [state, line]
               end
             when :error
-              meta['error'] = 'lock'
+              meta["error"] = "lock"
               log Paint[line, :red], depth: 2
             when :plan_error
               if phase != :plan_error
                 puts
                 phase = :plan_error
               end
-              meta['error'] = 'refresh'
+              meta["error"] = "refresh"
               log Paint[line, :red], depth: 2
             when :error_lock_info
               if line =~ /^  ([^ ]+):\s+([^ ].+)$/
@@ -64,9 +64,9 @@ module MuxTf
             when :refreshing
               if phase != :refreshing
                 phase = :refreshing
-                log 'Refreshing state ', depth: 2, newline: false
+                log "Refreshing state ", depth: 2, newline: false
               else
-                print '.'
+                print "."
               end
             when :refresh_done
               if phase != :refresh_done
@@ -83,7 +83,7 @@ module MuxTf
               p [state, line]
             end
           end
-        end
+        }
         [status.status, meta]
       end
 
@@ -104,7 +104,7 @@ module MuxTf
 
         parser.state(:plugin_warnings, /^$/, [:plugins])
 
-        status = tf_init(upgrade: true, color: false) do |raw_line|
+        status = tf_init(upgrade: true, color: false) { |raw_line|
           plan_output << raw_line
           parser.parse(raw_line.rstrip) do |state, line|
             case state
@@ -112,19 +112,19 @@ module MuxTf
               if phase != state
                 # first line
                 phase = state
-                log 'Upgrding modules ', depth: 1, newline: false
+                log "Upgrding modules ", depth: 1, newline: false
                 next
               end
               case line
               when /^- (?<module>[^ ]+) in (?<path>.+)$/
                 # info = $~.named_captures
                 # log "- #{info["module"]}", depth: 2
-                print '.'
+                print "."
               when /^Downloading (?<repo>[^ ]+) (?<version>[^ ]+) for (?<module>[^ ]+)\.\.\./
                 # info = $~.named_captures
                 # log "Downloading #{info["module"]} from #{info["repo"]} @ #{info["version"]}"
-                print 'D'
-              when ''
+                print "D"
+              when ""
                 puts
               else
                 p [state, line]
@@ -133,11 +133,11 @@ module MuxTf
               if phase != state
                 # first line
                 phase = state
-                log 'Initializing the backend ', depth: 1, newline: false
+                log "Initializing the backend ", depth: 1, newline: false
                 next
               end
               case line
-              when ''
+              when ""
                 puts
               else
                 p [state, line]
@@ -146,14 +146,14 @@ module MuxTf
               if phase != state
                 # first line
                 phase = state
-                log 'Initializing provider plugins ...', depth: 1
+                log "Initializing provider plugins ...", depth: 1
                 next
               end
               case line
-              when /^- Downloading plugin for provider "(?<provider>[^\"]+)" \((?<provider_path>[^\)]+)\) (?<version>.+)\.\.\.$/
+              when /^- Downloading plugin for provider "(?<provider>[^"]+)" \((?<provider_path>[^)]+)\) (?<version>.+)\.\.\.$/
                 info = $LAST_MATCH_INFO.named_captures
-                log "- #{info['provider']} #{info['version']}", depth: 2
-              when '- Checking for available provider plugins...'
+                log "- #{info["provider"]} #{info["version"]}", depth: 2
+              when "- Checking for available provider plugins..."
                 # noop
               else
                 p [state, line]
@@ -170,7 +170,7 @@ module MuxTf
               p [state, line]
             end
           end
-        end
+        }
 
         [status.status, meta]
       end
@@ -178,20 +178,20 @@ module MuxTf
       def process_validation(info)
         remedies = Set.new
 
-        if info['error_count'] > 0 || info['warning_count'] > 0
-          log "Encountered #{Paint[info['error_count'], :red]} Errors and #{Paint[info['warning_count'], :yellow]} Warnings!", depth: 2
-          info['diagnostics'].each do |dinfo|
-            color = dinfo['severity'] == 'error' ? :red : :yellow
-            log "#{Paint[dinfo['severity'].capitalize, color]}: #{dinfo['summary']}", depth: 3
-            if dinfo['detail']&.include?('terraform init')
+        if info["error_count"] > 0 || info["warning_count"] > 0
+          log "Encountered #{Paint[info["error_count"], :red]} Errors and #{Paint[info["warning_count"], :yellow]} Warnings!", depth: 2
+          info["diagnostics"].each do |dinfo|
+            color = dinfo["severity"] == "error" ? :red : :yellow
+            log "#{Paint[dinfo["severity"].capitalize, color]}: #{dinfo["summary"]}", depth: 3
+            if dinfo["detail"]&.include?("terraform init")
               remedies << :init
             else
-              log dinfo['detail'], depth: 4 if dinfo['detail']
-              if dinfo['range']
-                log format_validation_range(dinfo['range'], color), depth: 4
+              log dinfo["detail"], depth: 4 if dinfo["detail"]
+              if dinfo["range"]
+                log format_validation_range(dinfo["range"], color), depth: 4
               end
 
-              remedies << :unknown if dinfo['severity'] == 'error'
+              remedies << :unknown if dinfo["severity"] == "error"
             end
           end
         end
@@ -214,17 +214,17 @@ module MuxTf
 
         context_lines = 3
 
-        lines = range['start']['line']..range['end']['line']
-        columns = range['start']['column']..range['end']['column']
+        lines = range["start"]["line"]..range["end"]["line"]
+        columns = range["start"]["column"]..range["end"]["column"]
 
         # on ../../../modules/pods/jane_pod/main.tf line 151, in module "jane":
         # 151:   jane_resources_preset = var.jane_resources_presetx
         output = []
         lines_info = lines.size == 1 ? "#{lines.first}:#{columns.first}" : "#{lines.first}:#{columns.first} to #{lines.last}:#{columns.last}"
-        output << "on: #{range['filename']} line#{lines.size > 1 ? 's' : ''}: #{lines_info}"
+        output << "on: #{range["filename"]} line#{lines.size > 1 ? "s" : ""}: #{lines_info}"
 
-        if File.exist?(range['filename'])
-          file_lines = File.read(range['filename']).split("\n")
+        if File.exist?(range["filename"])
+          file_lines = File.read(range["filename"]).split("\n")
           extract_range = ([lines.first - context_lines, 0].max)..([lines.last + context_lines, file_lines.length - 1].min)
           file_lines.each_with_index do |line, index|
             if extract_range.cover?(index + 1)
@@ -237,7 +237,7 @@ module MuxTf
                   start_col = columns.last
                 end
                 painted_line = paint_line(line, color, start_col: start_col, end_col: end_col)
-                output << "#{Paint['>', color]} #{index + 1}: #{painted_line}"
+                output << "#{Paint[">", color]} #{index + 1}: #{painted_line}"
               else
                 output << "  #{index + 1}: #{line}"
               end