mux_tf 0.15.0 → 0.17.0

data/lib/mux_tf/cli/mux.rb

@@ -24,13 +24,174 @@ module MuxTf
           end
         end
 
-        def run(_args)
+        def run(args)
+          if ENV["MUX_V2"]
+            run_v2(args)
+          else
+            run_v1(args)
+          end
+        end
+
+        def run_create_session
+          project = File.basename(Dir.getwd)
+
+          if Tmux.session_running?(project)
+            log "Killing existing session ..."
+            Tmux.kill_session(project)
+          end
+
+          log "Starting new session ..."
+          with_clean_env do
+            Tmux.new_session project
+          end
+          Tmux.select_pane "initial"
+
+          window_id = Tmux.list_windows.first[:id]
+
+          Tmux.set "remain-on-exit", "on"
+
+          Tmux.set_hook "pane-exited", "select-layout tiled"
+          Tmux.set_hook "window-pane-changed", "select-layout tiled"
+          Tmux.set_hook "pane-exited", "select-layout tiled"
+
+          Tmux.set "mouse", "on"
+
+          puts "\e]0;tmux: #{project}\007"
+
+          Tmux.split_window :horizontal, "#{project}:#{window_id}", cwd: Dir.getwd,
+                                                                    cmd: File.expand_path(File.join(__dir__, "..", "..", "..", "exe", "tf_mux spawner"))
+          Tmux.select_pane "spawner"
+
+          initial_pane = Tmux.find_pane("initial")
+          Tmux.kill_pane initial_pane[:id]
+          Tmux.tile!
+
+          log "Attaching ..."
+          Tmux.attach(project)
+          log "Done!"
+        end
+
+        def parse_control_line(line)
+          keyword, remainder = line.split(" ", 2)
+          case keyword
+          when "%begin"
+            # n1, n2, n3, remainder = remainder.split(" ", 4)
+            p [:begin, n1, n2, n3, remainder]
+          when "%end"
+            # n1, n2, n3, remainder = remainder.split(" ", 4)
+            p [:end, n1, n2, n3, remainder]
+          when "%session-changed"
+            # n1, s1, remainder = remainder.split(" ", 3)
+            # p [:session_changed, n1, s1, remainder]
+          when "%window-pane-changed"
+            # n1, n2, remainder = remainder.split(" ", 3)
+            # p [:window_pane_changed, n1, n2, remainder]
+          when "%layout-change"
+            # ignore
+            # p [:layout_change, remainder]
+          when "%pane-mode-changed"
+            # ignore
+            p [:layout_change, remainder]
+          when "%subscription-changed"
+            sub_name, n1, n2, n3, n4, _, remainder = remainder.split(" ", 7)
+            if sub_name == "pane-info"
+              pane_id, pane_index, pane_title, pane_dead_status = remainder.strip.split(",", 4)
+              if pane_dead_status != ""
+                p [:pane_exited, pane_id, pane_index, pane_title, pane_dead_status]
+                Tmux.kill_pane(pane_id)
+                panes = Tmux.list_panes
+                if panes.length == 1 && panes.first[:name] == "spawner"
+                  Tmux.kill_pane(panes.first[:id])
+                  # its the last pane, so the whole thing should exit
+                end
+              end
+            else
+              p [:subscription_changed, sub_name, n1, n2, n3, n4, remainder]
+            end
+          when "%output"
+            pane, = remainder.split(" ", 2)
+            if pane == "%1"
+              # skip own output
+              # else
+              #   p [:output, pane, remainder]
+            end
+          else
+            p [keyword, remainder]
+          end
+        end
+
+        def run_spawner
+          project = File.basename(Dir.getwd)
+
+          control_thread = Thread.new do
+            puts "Control Thread Started"
+            Tmux.attach_control(project, on_spawn: lambda { |stdin|
+              stdin.write("refresh-client -B \"pane-info:%*:\#{pane_id},\#{pane_index},\#{pane_title},\#{pane_dead_status}\"\n")
+              stdin.flush
+            }, on_line: lambda { |stream, line|
+              if stream == :stdout
+                parse_control_line(line)
+                # p info
+              else
+                p [stream, line]
+              end
+            })
+            puts "Control Thread Exited"
+          end
+
+          begin
+            log "Enumerating folders ..."
+            dirs = enumerate_terraform_dirs
+
+            fail_with "Error: - no subfolders detected! Aborting." if dirs.empty?
+
+            tasks = dirs.map { |dir|
+              {
+                name: dir,
+                cwd: dir,
+                cmd: File.expand_path(File.join(__dir__, "..", "..", "..", "exe", "tf_current"))
+              }
+            }
+
+            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
+
+            window_id = Tmux.list_windows.first[:id]
+
+            return if tasks.empty?
+
+            tasks.each do |task|
+              log "launching task: #{task[:name]} ...", depth: 2
+              Tmux.split_window :horizontal, "#{project}:#{window_id}", 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
+          ensure
+            control_thread.join
+          end
+        end
+
+        def run_v2(args)
           Dotenv.load(".env.mux")
 
-          log "Enumerating folders ..."
-          dirs = enumerate_terraform_dirs
+          if args[0] == "spawner"
+            run_spawner
+          else
+            run_create_session
+          end
+        end
 
-          fail_with "Error: - no subfolders detected! Aborting." if dirs.empty?
+        def run_v1(_args)
+          Dotenv.load(".env.mux")
+
+          dirs = enumerate_terraform_dirs
 
           tasks = dirs.map { |dir|
             {
@@ -104,7 +265,9 @@ module MuxTf
           ignored += ENV["MUX_IGNORE"].split(",") if ENV["MUX_IGNORE"]
 
           dirs = Dir["**/.terraform.lock.hcl"].map { |f| File.dirname(f) }
-          dirs.reject! do |d| d.in?(ignored) end
+          dirs.reject! do |d|
+            d.in?(ignored)
+          end
 
           dirs
         end

data/lib/mux_tf/cli/plan_summary.rb

@@ -6,19 +6,15 @@ module MuxTf
       extend PiotrbCliUtils::Util
       extend PiotrbCliUtils::ShellHelpers
       extend TerraformHelpers
-      import Coloring
+      include Coloring
 
       class << self
         def run(args)
           options = {
-            interactive: false,
             hierarchy: false
           }
 
           args = OptionParser.new { |opts|
-            opts.on("-i") do |v|
-              options[:interactive] = v
-            end
             opts.on("-h") do |v|
               options[:hierarchy] = v
             end
@@ -32,25 +28,20 @@ module MuxTf
                    PlanSummaryHandler.from_data(JSON.parse($stdin.read))
                  end
 
-          if options[:interactive]
-            abort_message = catch(:abort) { plan.run_interactive }
-            log pastel.red("Aborted: #{abort_message}") if abort_message
+          if options[:hierarchy]
+            plan.nested_summary.each do |line|
+              puts line
+            end
           else
-            if options[:hierarchy]
-              plan.nested_summary.each do |line|
-                puts line
-              end
-            else
-              plan.flat_summary.each do |line|
-                puts line
-              end
-              plan.output_summary.each do |line|
-                puts line
-              end
+            plan.flat_summary.each do |line|
+              puts line
+            end
+            plan.output_summary.each do |line|
+              puts line
             end
-            puts
-            puts plan.summary
           end
+          puts
+          puts plan.summary
         end
       end
     end

data/lib/mux_tf/error_handling_methods.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module ErrorHandlingMethods
+    def setup_error_handling(parser, from_states:)
+      parser.state(:init_error, /^Terraform encountered problems during initialisation/, [:none])
+      parser.state(:error_block, /^╷/, from_states | [:after_error, :init_error])
+      parser.state(:error_block_error, /^│ Error: /, [:error_block, :init_error])
+      parser.state(:error_block_warning, /^│ Warning: /, [:error_block, :init_error])
+      parser.state(:after_error, /^╵/, [:error_block, :error_block_error, :error_block_warning, :init_error])
+    end
+
+    def handle_error_states(meta, state, line)
+      case state
+      when :error_block
+        if meta[:init_error]
+          # turn this into an error first
+          meta[:errors] ||= []
+          meta[:errors] << {
+            type: :error,
+            message: meta[:init_error].join("\n")
+            # body: meta[:init_error]
+          }
+          meta.delete(:init_error)
+        end
+        meta[:current_error] = {
+          type: :unknown,
+          body: []
+        }
+      when :error_block_error, :error_block_warning
+        clean_line = pastel.strip(line).gsub(/^│ /, "")
+        if clean_line =~ /^(Warning|Error): (.+)$/
+          meta[:current_error][:type] = $LAST_MATCH_INFO[1].downcase.to_sym
+          meta[:current_error][:message] = $LAST_MATCH_INFO[2]
+        elsif clean_line == ""
+          # skip double empty lines
+          meta[:current_error][:body] << clean_line if meta[:current_error][:body].last != ""
+        else
+          meta[:current_error][:body] ||= []
+          meta[:current_error][:body] << clean_line
+        end
+      when :after_error
+        case pastel.strip(line)
+        when "╵" # closing of an error block
+          if meta[:current_error][:type] == :error
+            meta[:errors] ||= []
+            meta[:errors] << meta[:current_error]
+          end
+          if meta[:current_error][:type] == :warning
+            meta[:warnings] ||= []
+            meta[:warnings] << meta[:current_error]
+          end
+          meta.delete(:current_error)
+        end
+      when :init_error
+        meta[:init_error] ||= []
+        meta[:init_error] << line
+      else
+        return false
+      end
+      true
+    end
+
+    def log_unhandled_line(state, line, reason: nil)
+      p [state, pastel.strip(line), reason]
+    end
+
+    def print_errors(meta)
+      meta[:errors]&.each do |error|
+        log "-" * 20
+        log pastel.red("Error: #{error[:message]}")
+        error[:body]&.each do |line|
+          log pastel.red(line), depth: 1
+        end
+        log ""
+      end
+    end
+  end
+end

data/lib/mux_tf/formatter_common.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module FormatterCommon
+    def tf_cmd_json(cmd_call_proc, &block)
+      last_stderr_line = nil
+      handler = proc { |(stream, raw_line)| # rubocop:disable Metrics/BlockLength
+        case stream
+        when :command
+          log "Running command: #{raw_line.strip} ...", depth: 2
+        when :stdout
+          begin
+            parsed_line = JSON.parse(raw_line)
+            parsed_line.keys.each do |key|
+              if key[0] == "@"
+                parsed_line[key[1..]] = parsed_line[key]
+                parsed_line.delete(key)
+              end
+            end
+            parsed_line.symbolize_keys!
+            parsed_line[:stream] = stream
+            if last_stderr_line
+              emit_line_helper(last_stderr_line, &block)
+              last_stderr_line = nil
+            end
+            emit_line_helper(parsed_line, &block)
+          rescue JSON::ParserError
+            # eg: "[WARN] Provider spacelift-io/spacelift (registry.opentofu.org) gpg key expired, this will fail in future versions of OpenTofu\n"
+            # treat the line as a normal log line
+            parsed_line = {
+              message: raw_line.strip,
+              module: "non-json-log"
+            }
+            parsed_line[:level] = raw_line[0..-2].strip if raw_line.match?(/^[A-Z]+/)
+            parsed_line[:stream] = stream
+            emit_line_helper(parsed_line, &block)
+          end
+        when :stderr
+          parsed_line = parse_non_json_plan_line(raw_line)
+          parsed_line[:stream] = stream
+
+          if parsed_line[:blank]
+            if last_stderr_line
+              emit_line_helper(last_stderr_line, &block)
+              last_stderr_line = nil
+            end
+          elsif parsed_line[:merge_up]
+            if last_stderr_line
+              last_stderr_line[:message] += "\n#{parsed_line[:message]}"
+            else
+              # this is just a standalone message then
+              parsed_line.delete(:merge_up)
+              last_stderr_line = parsed_line
+            end
+          elsif last_stderr_line
+            emit_line_helper(last_stderr_line, &block)
+            last_stderr_line = parsed_line
+          else
+            last_stderr_line = parsed_line
+          end
+        end
+      }
+
+      status = cmd_call_proc.call(handler)
+
+      emit_line_helper(last_stderr_line, &block) if last_stderr_line
+      status
+    end
+
+    def parse_non_json_plan_line(raw_line)
+      result = {}
+
+      if raw_line.match(/^time=(?<timestamp>[^ ]+) level=(?<level>[^ ]+) msg=(?<message>.+?)(?: prefix=\[(?<prefix>.+?)\])?\s*$/)
+        result.merge!($LAST_MATCH_INFO.named_captures.symbolize_keys)
+        result[:module] = "terragrunt"
+        result.delete(:prefix) unless result[:prefix]
+        result[:prefix] = Pathname.new(result[:prefix]).relative_path_from(Dir.getwd).to_s if result[:prefix]
+
+        result[:merge_up] = true if result[:message].match(/^\d+ errors? occurred:$/)
+      elsif raw_line.strip == ""
+        result[:blank] = true
+      else
+        result[:message] = raw_line
+        result[:merge_up] = true
+      end
+
+      # time=2023-08-25T11:44:41-07:00 level=error msg=Terraform invocation failed in /Users/piotr/Work/janepods/.terragrunt-cache/BM86IAj5tW4bZga2lXeYT8tdOKI/V0IEypKSfyl-kHfCnRNAqyX02V8/modules/event-bus prefix=[/Users/piotr/Work/janepods/accounts/eks-dev/admin/apps/kube-system-event-bus]
+      # time=2023-08-25T11:44:41-07:00 level=error msg=1 error occurred:
+      #         * [/Users/piotr/Work/janepods/.terragrunt-cache/BM86IAj5tW4bZga2lXeYT8tdOKI/V0IEypKSfyl-kHfCnRNAqyX02V8/modules/event-bus] exit status 2
+      #
+      #
+      result
+    end
+
+    def emit_line_helper(result, &block)
+      result[:level] ||= result[:stream] == :stderr ? "error" : "info"
+      result[:module] ||= result[:stream]
+      result[:type] ||= "unknown"
+
+      result[:message].lstrip! if result[:message] =~ /^\n/
+
+      if result[:message].match(/^Terraform invocation failed in (.+)/)
+        result[:type] = "tf_failed"
+
+        lines = result[:message].split("\n")
+        result[:diagnostic] = {
+          "summary" => "Terraform invocation failed",
+          "detail" => result[:message],
+          roots: [],
+          extra: []
+        }
+
+        lines.each do |line|
+          if line.match(/^\s+\* \[(.+)\] exit status (\d+)$/)
+            result[:diagnostic][:roots] << {
+              path: $LAST_MATCH_INFO[1],
+              status: $LAST_MATCH_INFO[2].to_i
+            }
+          elsif line.match(/^\d+ errors? occurred$/)
+            # noop
+          else
+            result[:diagnostic][:extra] << line
+          end
+        end
+
+        result[:message] = "Terraform invocation failed"
+      end
+
+      block.call(result)
+    end
+
+    def print_unhandled_error_line(parsed_line)
+      if parsed_line[:diagnostic]
+        color = :red
+        dinfo = parsed_line[:diagnostic]
+
+        log "#{pastel.decorate(dinfo['severity'].capitalize, color)}: #{dinfo['summary']}", depth: 3
+        log dinfo["detail"].split("\n"), depth: 4 if dinfo["detail"]
+        log format_validation_range(dinfo, color), depth: 4 if dinfo["range"]
+      elsif parsed_line[:message] =~ /^\[reset\]/
+        log pastel.red(parsed_line[:message].gsub(/^\[reset\]/, "")), depth: 3
+      else
+        p parsed_line
+      end
+    end
+
+    def format_validation_range(dinfo, color)
+      range = dinfo["range"]
+
+      # 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 = if lines.size == 1
+                     "#{lines.first}:#{columns.first}"
+                   else
+                     "#{lines.first}:#{columns.first} to #{lines.last}:#{columns.last}"
+                   end
+      output << "on: #{range['filename']} line#{lines.size > 1 ? 's' : ''}: #{lines_info}"
+
+      # TODO: in terragrunt mode, we need to somehow figure out the path to the cache root, all the paths will end up being relative to that
+      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 << "#{pastel.decorate('>', color)} #{index + 1}: #{painted_line}"
+            else
+              output << "  #{index + 1}: #{line}"
+            end
+          end
+        end
+      elsif dinfo["snippet"]
+        snippet = dinfo["snippet"]
+        # {
+        #   "context"=>"locals",
+        #   "code"=>"        aws_iam_policy.crossplane_aws_ecr.arn",
+        #   "start_line"=>72,
+        #   "highlight_start_offset"=>8,
+        #   "highlight_end_offset"=>41,
+        #   "values"=>[]
+        # }
+        output << "Code:"
+        output << "in #{snippet['context']}" if snippet["context"]
+        line = snippet["start_line"]
+        snippet["code"].split("\n").each do |l|
+          output << "#{line}: #{l}"
+          line += 1
+        end
+      end
+
+      if dinfo["snippet"] && dinfo["snippet"]["values"]&.any?
+        snippet = dinfo["snippet"]
+        output << ""
+        output << "Values:"
+        snippet["values"].each do |value|
+          output << "  #{pastel.bold(value['traversal'])} #{value['statement']}"
+        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..]
+      middle = line[start_col - 1..end_col - 1]
+      "#{prefix}#{pastel.decorate(middle, *paint_options)}#{suffix}"
+    end
+
+    def print_tg_error_line(parsed_line)
+      parsed_line[:message].split("\n").each do |line|
+        next if line.strip == ""
+
+        parsed_message = JSON.parse(line)
+        raw_prefix = "[TG ERROR] "
+        prefix = pastel.red(raw_prefix)
+        index = 0
+        lines = parsed_message["msg"].split("\n").map { |l|
+          l = if index.zero?
+                prefix + l
+              else
+                (" " * raw_prefix.length) + l
+              end
+          index += 1
+          l
+        }
+        log lines, depth: 1
+      end
+    end
+  end
+end

data/lib/mux_tf/handlers/plan_handler.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Handlers
+    class PlanHandler
+    end
+  end
+end

data/lib/mux_tf/handlers.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Handlers
+  end
+end