mux_tf 0.1.2

data/lib/mux_tf/cli/mux.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Cli
+    module Mux
+      extend PiotrbCliUtils::Util
+      extend PiotrbCliUtils::ShellHelpers
+
+      class << self
+        def run(_args)
+          Dotenv.load('.env.mux')
+
+          log 'Enumerating folders ...'
+          dirs = enumerate_terraform_dirs
+
+          fail_with 'Error: - no subfolders detected! Aborting.' if dirs.empty?
+
+          tasks = dirs.map do |dir|
+            {
+              name: dir,
+              cwd: dir,
+              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)
+            p JSON.parse(result)
+          end
+
+          if Tmux.session_running?(project)
+            log 'Killing existing session ...'
+            Tmux.kill_session(project)
+          end
+
+          log 'Starting new session ...'
+          Tmux.new_session project
+          Tmux.select_pane 'initial'
+
+          Tmux.set_hook 'pane-exited', 'select-layout tiled'
+          Tmux.set_hook 'window-pane-changed', 'select-layout tiled'
+
+          Tmux.set 'mouse', 'on'
+
+          unless tasks.empty?
+            tasks.each do |task|
+              log "launching task: #{task[:name]} ...", depth: 2
+              Tmux.split_window :horizontal, "#{project}:1", cmd: task[:cmd], cwd: task[:cwd]
+              Tmux.select_pane task[:name]
+              Tmux.tile!
+              task[:commands]&.each do |cmd|
+                Tmux.send_keys cmd, enter: true
+              end
+            end
+          end
+
+          log 'Almost done ...'
+
+          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!'
+        end
+
+        private
+
+        def enumerate_terraform_dirs
+          ignored = []
+
+          ignored += ENV['MUX_IGNORE'].split(',') if ENV['MUX_IGNORE']
+
+          dirs = Dir['**/*/.terraform'].map { |n| n.gsub(%r{/\.terraform}, '') }
+          dirs.reject! { |d| d.in?(ignored) }
+
+          dirs
+        end
+      end
+    end
+  end
+end

data/lib/mux_tf/cli/plan_summary.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Cli
+    module PlanSummary
+      extend PiotrbCliUtils::Util
+      extend PiotrbCliUtils::ShellHelpers
+      extend TerraformHelpers
+
+      class << self
+        def run(args)
+          options = {
+            interactive: false,
+            hierarchy: false
+          }
+
+          args = OptionParser.new do |opts|
+            opts.on('-i') do |v|
+              options[:interactive] = v
+            end
+            opts.on('-h') do |v|
+              options[:hierarchy] = v
+            end
+          end.parse!(args)
+
+          if options[:interactive]
+            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])
+          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]}"
+          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]
+            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
+            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
+              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']
+              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?
+          end
+          parts.join('.')
+        end
+      end
+    end
+  end
+end

data/lib/mux_tf/plan_formatter.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module MuxTf
+  class PlanFormatter
+    extend TerraformHelpers
+    extend PiotrbCliUtils::Util
+
+    class << self
+      # include CommandHelpers
+
+      def pretty_plan(filename)
+        pastel = Pastel.new
+
+        plan_output = String.new
+
+        phase = :init
+
+        meta = {}
+
+        parser = StatefulParser.new(normalizer: pastel.method(:strip))
+        parser.state(:info, /^Acquiring state lock/)
+        parser.state(:error, /Error locking state/, %i[none blank info])
+        parser.state(:refreshing, /Refreshing Terraform state in-memory prior to plan.../, %i[none blank info])
+        parser.state(:refresh_done, /^----------+$/, [:refreshing])
+        parser.state(:plan_info, /Terraform will perform the following actions:/, [:refresh_done])
+        parser.state(:plan_summary, /^Plan:/, [:plan_info])
+
+        parser.state(:error_lock_info, /Lock Info/, [:error])
+        parser.state(:error, /^$/, [:error_lock_info])
+
+        parser.state(:plan_error, /^Error: /, [:refreshing])
+
+        status = tf_plan(out: filename, detailed_exitcode: true, compact_warnings: true) do |raw_line|
+          plan_output << raw_line
+          parser.parse(raw_line.rstrip) do |state, line|
+            case state
+            when :none
+              if line.blank?
+                # nothing
+              else
+                p [state, line]
+              end
+            when :info
+              if /Acquiring state lock. This may take a few moments.../.match?(line)
+                log 'Acquiring state lock ...', depth: 2
+              else
+                p [state, line]
+              end
+            when :error
+              meta['error'] = 'lock'
+              log Paint[line, :red], depth: 2
+            when :plan_error
+              if phase != :plan_error
+                puts
+                phase = :plan_error
+              end
+              meta['error'] = 'refresh'
+              log Paint[line, :red], depth: 2
+            when :error_lock_info
+              if line =~ /^  ([^ ]+):\s+([^ ].+)$/
+                meta[$LAST_MATCH_INFO[1]] = $LAST_MATCH_INFO[2]
+              end
+              log Paint[line, :red], depth: 2
+            when :refreshing
+              if phase != :refreshing
+                phase = :refreshing
+                log 'Refreshing state ', depth: 2, newline: false
+              else
+                print '.'
+              end
+            when :refresh_done
+              if phase != :refresh_done
+                phase = :refresh_done
+                puts
+              else
+                # nothing
+              end
+            when :plan_info
+              log line, depth: 2
+            when :plan_summary
+              log line, depth: 2
+            else
+              p [state, line]
+            end
+          end
+        end
+        [status.status, meta]
+      end
+
+      def process_upgrade
+        pastel = Pastel.new
+
+        plan_output = String.new
+
+        phase = :init
+
+        meta = {}
+
+        parser = StatefulParser.new(normalizer: pastel.method(:strip))
+
+        parser.state(:modules, /^Upgrading modules\.\.\./)
+        parser.state(:backend, /^Initializing the backend\.\.\./, [:modules])
+        parser.state(:plugins, /^Initializing provider plugins\.\.\./, [:backend])
+
+        parser.state(:plugin_warnings, /^$/, [:plugins])
+
+        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
+              if phase != state
+                # first line
+                phase = state
+                log 'Upgrding modules ', depth: 1, newline: false
+                next
+              end
+              case line
+              when /^- (?<module>[^ ]+) in (?<path>.+)$/
+                # info = $~.named_captures
+                # log "- #{info["module"]}", depth: 2
+                print '.'
+              when /^Downloading (?<repo>[^ ]+) (?<version>[^ ]+) for (?<module>[^ ]+)\.\.\./
+                # info = $~.named_captures
+                # log "Downloading #{info["module"]} from #{info["repo"]} @ #{info["version"]}"
+                print 'D'
+              when ''
+                puts
+              else
+                p [state, line]
+              end
+            when :backend
+              if phase != state
+                # first line
+                phase = state
+                log 'Initializing the backend ', depth: 1, newline: false
+                next
+              end
+              case line
+              when ''
+                puts
+              else
+                p [state, line]
+              end
+            when :plugins
+              if phase != state
+                # first line
+                phase = state
+                log 'Initializing provider plugins ...', depth: 1
+                next
+              end
+              case line
+              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]
+              end
+            when :plugin_warnings
+              if phase != state
+                # first line
+                phase = state
+                next
+              end
+
+              log Paint[line, :yellow], depth: 1
+            else
+              p [state, line]
+            end
+          end
+        end
+
+        [status.status, meta]
+      end
+
+      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')
+              remedies << :init
+            else
+              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'
+            end
+          end
+        end
+
+        remedies
+      end
+
+      private
+
+      def format_validation_range(range, color)
+        # filename: "../../../modules/pods/jane_pod/main.tf"
+        # start:
+        #   line: 151
+        #   column: 27
+        #   byte: 6632
+        # end:
+        #   line: 151
+        #   column: 53
+        #   byte: 6658
+
+        context_lines = 3
+
+        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}"
+
+        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)
+              if lines.cover?(index + 1)
+                start_col = 1
+                end_col = :max
+                if index + 1 == lines.first
+                  start_col = columns.first
+                elsif index + 1 == lines.last
+                  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}"
+              else
+                output << "  #{index + 1}: #{line}"
+              end
+            end
+          end
+        end
+
+        output
+      end
+
+      def paint_line(line, *paint_options, start_col: 1, end_col: :max)
+        end_col = line.length if end_col == :max
+        prefix = line[0, start_col - 1]
+        suffix = line[end_col..-1]
+        middle = line[start_col - 1..end_col - 1]
+        "#{prefix}#{Paint[middle, *paint_options]}#{suffix}"
+      end
+    end
+  end
+end