mux_tf 0.2.4 → 0.4.0

data/lib/mux_tf/cli/mux.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "bundler"
+
 module MuxTf
   module Cli
     module Mux
@@ -7,44 +9,63 @@ module MuxTf
       extend PiotrbCliUtils::ShellHelpers
 
       class << self
+        def with_clean_env
+          backup = {}
+          Bundler.with_original_env do
+            ENV.keys.grep(/^(RBENV_|RUBYLIB)/).each do |key|
+              backup[key] = ENV[key]
+              ENV.delete(key)
+            end
+            yield
+          end
+        ensure
+          backup.each do |k, v|
+            ENV[k] = v
+          end
+        end
+
         def run(_args)
-          Dotenv.load('.env.mux')
+          Dotenv.load(".env.mux")
 
-          log 'Enumerating folders ...'
+          log "Enumerating folders ..."
           dirs = enumerate_terraform_dirs
 
-          fail_with 'Error: - no subfolders detected! Aborting.' if dirs.empty?
+          fail_with "Error: - no subfolders detected! Aborting." if dirs.empty?
 
-          tasks = dirs.map do |dir|
+          tasks = dirs.map { |dir|
             {
               name: dir,
               cwd: dir,
-              cmd: File.expand_path(File.join(__dir__, '..', '..', '..', 'exe', 'tf_current'))
+              cmd: File.expand_path(File.join(__dir__, "..", "..", "..", "exe", "tf_current"))
             }
-          end
+          }
 
           project = File.basename(Dir.getwd)
 
-          if ENV['MUX_TF_AUTH_WRAPPER']
-            log 'Warming up AWS connection ...'
-            words = Shellwords.shellsplit(ENV['MUX_TF_AUTH_WRAPPER'])
-            result = capture_shell([*words, 'aws', 'sts', 'get-caller-identity'], raise_on_error: true)
+          if ENV["MUX_TF_AUTH_WRAPPER"]
+            log "Warming up AWS connection ..."
+            words = Shellwords.shellsplit(ENV["MUX_TF_AUTH_WRAPPER"])
+            result = capture_shell([*words, "aws", "sts", "get-caller-identity"], raise_on_error: true)
             p JSON.parse(result)
           end
 
           if Tmux.session_running?(project)
-            log 'Killing existing session ...'
+            log "Killing existing session ..."
             Tmux.kill_session(project)
           end
 
-          log 'Starting new session ...'
-          Tmux.new_session project
-          Tmux.select_pane 'initial'
+          log "Starting new session ..."
+          with_clean_env do
+            Tmux.new_session project
+          end
+          Tmux.select_pane "initial"
 
-          Tmux.set_hook 'pane-exited', 'select-layout tiled'
-          Tmux.set_hook 'window-pane-changed', 'select-layout tiled'
+          # Tmux.set "remain-on-exit", "on"
 
-          Tmux.set 'mouse', 'on'
+          Tmux.set_hook "pane-exited", "select-layout tiled"
+          Tmux.set_hook "window-pane-changed", "select-layout tiled"
+
+          Tmux.set "mouse", "on"
 
           window_id = Tmux.list_windows.first[:id]
 
@@ -60,17 +81,19 @@ module MuxTf
             end
           end
 
-          log 'Almost done ...'
+          log "Almost done ..."
 
-          initial_pane = Tmux.find_pane('initial')
+          initial_pane = Tmux.find_pane("initial")
           Tmux.kill_pane initial_pane[:id]
           Tmux.tile!
 
           puts "\e]0;tmux: #{project}\007"
 
-          log 'Attaching ...'
-          Tmux.attach(project, cc: !!ENV['MUXP_CC_MODE'])
-          log 'Done!'
+          sleep 1
+
+          log "Attaching ..."
+          Tmux.attach(project, cc: !!ENV["MUXP_CC_MODE"])
+          log "Done!"
         end
 
         private
@@ -78,9 +101,9 @@ module MuxTf
         def enumerate_terraform_dirs
           ignored = []
 
-          ignored += ENV['MUX_IGNORE'].split(',') if ENV['MUX_IGNORE']
+          ignored += ENV["MUX_IGNORE"].split(",") if ENV["MUX_IGNORE"]
 
-          dirs = Dir['**/*/.terraform'].map { |n| n.gsub(%r{/\.terraform}, '') }
+          dirs = Dir["**/*/.terraform"].map { |n| n.gsub(%r{/\.terraform}, "") }
           dirs.reject! { |d| d.in?(ignored) }
 
           dirs

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

@@ -6,13 +6,9 @@ module MuxTf
     extend PiotrbCliUtils::Util
 
     class << self
-      # include CommandHelpers
-
       def pretty_plan(filename)
         pastel = Pastel.new
 
-        plan_output = String.new
-
         phase = :init
 
         meta = {}
@@ -30,8 +26,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|
-          plan_output << raw_line
+        status = tf_plan(out: filename, detailed_exitcode: true, compact_warnings: true) { |raw_line|
           parser.parse(raw_line.rstrip) do |state, line|
             case state
             when :none
@@ -42,19 +37,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 +59,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,14 +78,25 @@ module MuxTf
               p [state, line]
             end
           end
-        end
+        }
         [status.status, meta]
       end
 
-      def process_upgrade
-        pastel = Pastel.new
+      def init_status_to_remedies(status, meta)
+        remedies = Set.new
+        if status != 0
+          if meta[:need_reconfigure]
+            remedies << :reconfigure
+          else
+            p [status, meta]
+            remedies << :unknown
+          end
+        end
+        remedies
+      end
 
-        plan_output = String.new
+      def run_tf_init(upgrade: nil, reconfigure: nil)
+        pastel = Pastel.new
 
         phase = :init
 
@@ -98,62 +104,104 @@ module MuxTf
 
         parser = StatefulParser.new(normalizer: pastel.method(:strip))
 
-        parser.state(:modules, /^Upgrading modules\.\.\./)
-        parser.state(:backend, /^Initializing the backend\.\.\./, [:modules])
+        parser.state(:modules_init, /^Initializing modules\.\.\./)
+        parser.state(:modules_upgrade, /^Upgrading modules\.\.\./)
+        parser.state(:backend, /^Initializing the backend\.\.\./, [:modules_init, :modules_upgrade])
         parser.state(:plugins, /^Initializing provider plugins\.\.\./, [:backend])
 
         parser.state(:plugin_warnings, /^$/, [:plugins])
+        parser.state(:backend_error, /Error:/, [:backend])
+
+        status = tf_init(upgrade: upgrade, reconfigure: reconfigure) { |raw_line|
+          stripped_line = pastel.strip(raw_line.rstrip)
 
-        status = tf_init(upgrade: true, color: false) do |raw_line|
-          plan_output << raw_line
           parser.parse(raw_line.rstrip) do |state, line|
             case state
-            when :modules
+            when :modules_init
+              if phase != state
+                phase = state
+                log "Initializing modules ", depth: 1
+                next
+              end
+              case stripped_line
+              when ""
+                puts
+              else
+                p [state, stripped_line]
+              end
+            when :modules_upgrade
               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
+              case stripped_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]
+                p [state, stripped_line]
               end
             when :backend
               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 ''
+              case stripped_line
+              when /^Successfully configured/
+                log line, depth: 2
+              when /unless the backend/
+                log line, depth: 2
+              when ""
                 puts
               else
-                p [state, line]
+                p [state, stripped_line]
+              end
+            when :backend_error
+              if raw_line.match "terraform init -reconfigure"
+                meta[:need_reconfigure] = true
+                log Paint["module needs to be reconfigured", :red], depth: 2
               end
             when :plugins
               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>.+)\.\.\.$/
+              case stripped_line
+              when /^- (?<module>.+) is built in to Terraform$/
                 info = $LAST_MATCH_INFO.named_captures
-                log "- #{info['provider']} #{info['version']}", depth: 2
-              when '- Checking for available provider plugins...'
+                log "- [BUILTIN] #{info["module"]}", depth: 2
+              when /^- Finding (?<module>[^ ]+) versions matching "(?<version>.+)"\.\.\./
+                info = $LAST_MATCH_INFO.named_captures
+                log "- [FIND] #{info["module"]} matching #{info["version"].inspect}", depth: 2
+              when /^- Finding latest version of (?<module>.+)\.\.\.$/
+                info = $LAST_MATCH_INFO.named_captures
+                log "- [FIND] #{info["module"]}", depth: 2
+              when /^- Installing (?<module>[^ ]+) v(?<version>.+)\.\.\.$/
+                info = $LAST_MATCH_INFO.named_captures
+                log "- [INSTALLING] #{info["module"]} v#{info["version"]}", depth: 2
+              when /^- Installed (?<module>[^ ]+) v(?<version>.+) \(signed by( a)? (?<signed>.+)\)$/
+                info = $LAST_MATCH_INFO.named_captures
+                log "- [INSTALLED] #{info["module"]} v#{info["version"]} (#{info["signed"]})", depth: 2
+              when /^- Using previously-installed (?<module>[^ ]+) v(?<version>.+)$/
+                info = $LAST_MATCH_INFO.named_captures
+                log "- [USING] #{info["module"]} v#{info["version"]}", depth: 2
+              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..."
                 # noop
               else
                 p [state, line]
@@ -170,7 +218,7 @@ module MuxTf
               p [state, line]
             end
           end
-        end
+        }
 
         [status.status, meta]
       end
@@ -178,20 +226,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 +262,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 +285,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