mux_tf 0.16.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f2bcb9ac31603cfab773175a4d81a7ab85e8cd44124dbdf7287234dd70537db
-  data.tar.gz: e50b7671fabc4ca94703452daef5fa3a0322f2f4fce103d2a1f02b05012e80a1
+  metadata.gz: 4daae54b1c3dec534cbea1d885966275435c29d6a528afac0a406c574fe5d559
+  data.tar.gz: 5c92881a86eac6d57e955a4194fa78119f5e86934d0b52cbacff473a3d8ddb1a
 SHA512:
-  metadata.gz: 5bf42a828264de913553c309f8acf9274175a7a2a2e9bc71f04534e91649ca6e91727ccf21677406f52d71331771935ead9f2011c4bb6b4780988174b7860767
-  data.tar.gz: abaaff54837201173a5c2ccaa796e2c501d48f4f8d72c46687b6275b6541037284be57dd8090c88d4d88c3eeee8983f68b03ce85e6a6bea4d98df914d1e62dbd
+  metadata.gz: e1ff3f7eb9936e8eeb0c1f56463405cba9f2b996ac3ff05aee914698ee447befec00ae845ec14328ab7b2e6e80201a63ae7d99dcd5ac424584843ec2091c724e
+  data.tar.gz: bb01ac4e5fbfe60f3ea9aadab25c42543c53c55757c86da14e2ab1eef1d707b35a5b76f9bacb4d075eca00fa58c16eb278cffe1497612ac6cca91b5bb0934caa

data/lib/mux_tf/cli/current/plan_command.rb

@@ -8,6 +8,8 @@ module MuxTf
         include PiotrbCliUtils::CriCommandSupport
         extend PiotrbCliUtils::Util
 
+        attr_reader :last_lock_info
+
         def plan_cmd
           define_cmd("plan", summary: "Re-run plan") do |_opts, _args, _cmd|
             run_validate && run_plan
@@ -52,12 +54,25 @@ module MuxTf
           when :error
             log "something went wrong", depth: 1
           when :changes
-            unless ENV["JSON_PLAN"]
+            if ENV["JSON_PLAN"]
+              plan_filename = PlanFilenameGenerator.for_path
+              plan = PlanSummaryHandler.from_file(plan_filename)
+
+              log plan.plan_text_output
+
+              log ""
+
+              plan.simple_summary do |line|
+                log line, depth: 2
+              end
+            else
               log "Printing Plan Summary ...", depth: 1
               plan_filename = PlanFilenameGenerator.for_path
-              pretty_plan_summary(plan_filename)
+              plan = PlanSummaryHandler.from_file(plan_filename)
+              plan.simple_summary do |line|
+                log line, depth: 2
+              end
             end
-            puts plan_summary_text if ENV["JSON_PLAN"]
           when :unknown
             # nothing
           end
@@ -110,13 +125,6 @@ module MuxTf
             created: meta["Created"]
           }
         end
-
-        def pretty_plan_summary(filename)
-          plan = PlanSummaryHandler.from_file(filename)
-          plan.simple_summary do |line|
-            log line, depth: 2
-          end
-        end
       end
     end
   end

data/lib/mux_tf/cli/current.rb

@@ -14,15 +14,60 @@ module MuxTf
       class << self
         attr_accessor :plan_command
 
+        def detect_tool_type(tool_cmd: nil)
+          tool_cmd ||= ENV.fetch("MUX_TF_BASE_CMD", "terraform")
+          output = `#{tool_cmd} --version`
+          case output
+          when /^Terraform v(.+)$/
+            {
+              tool_name: "terraform",
+              tool_version: ::Regexp.last_match(1)
+            }
+          when /^OpenTofu v(.+)$/
+            {
+              tool_name: "opentofu",
+              tool_version: ::Regexp.last_match(1)
+            }
+          when /^terragrunt version v(.+)$/
+            result = {
+              tool_wrapper: "terragrunt",
+              tool_wrapper_version: ::Regexp.last_match(1)
+            }
+            tg_tool = ENV.fetch("TG_TF_PATH", "tofu")
+            result.merge! detect_tool_type(tool_cmd: tg_tool)
+            result
+          else
+            raise "can't parse tool version from: #{output.inspect}"
+          end
+        end
+
+        def init_tool_env
+          info = detect_tool_type
+
+          if %w[terraform opentofu].include?(info[:tool_name])
+            ENV["TF_IN_AUTOMATION"] = "1"
+            ENV["TF_INPUT"] = "0"
+          end
+
+          return unless info[:tool_wrapper] == "terragrunt"
+
+          if Gem::Version.new(info[:tool_wrapper_version]) >= Gem::Version.new("0.70.0")
+            # new syntax
+            ENV["TG_LOG_FORMAT"] = "json"
+            ENV["TG_TF_FORWARD_STDOUT"] = "true"
+          else
+            # old syntax
+            ENV["TERRAGRUNT_JSON_LOG"] = "1"
+            ENV["TERRAGRUNT_FORWARD_TF_STDOUT"] = "1"
+          end
+        end
+
         def run(args)
           version_check
 
           self.plan_command = PlanCommand.new
 
-          ENV["TF_IN_AUTOMATION"] = "1"
-          ENV["TF_INPUT"] = "0"
-          ENV["TERRAGRUNT_JSON_LOG"] = "1"
-          ENV["TERRAGRUNT_FORWARD_TF_STDOUT"] = "1"
+          init_tool_env
 
           if args[0] == "cli"
             cmd_loop
@@ -36,6 +81,7 @@ module MuxTf
             if args[0] && valid_commands.include?(args[0])
               stop_reason = catch(:stop) {
                 root_cmd.run(args, {}, hard_exit: true)
+                nil
               }
               log pastel.red("Stopped: #{stop_reason}") if stop_reason
               return
@@ -94,6 +140,8 @@ module MuxTf
           end
 
           meta[:warnings]&.each do |warning|
+            next if warning[:printed]
+
             log "-" * 20
             log pastel.yellow("Warning: #{warning[:message]}")
             warning[:body]&.each do |line|
@@ -103,6 +151,8 @@ module MuxTf
           end
 
           meta[:errors]&.each do |error|
+            next if error[:printed]
+
             log "-" * 20
             log pastel.red("Error: #{error[:message]}")
             error[:body]&.each do |line|
@@ -149,12 +199,21 @@ module MuxTf
             log wrap_log["unprocessed remedies: #{remedies.to_a}", color: :red], depth: 1
             return [false, results]
           end
+          if remedies.delete? :user_error
+            remedy = :user_error
+            log wrap_log["user error encountered!", color: :red]
+            log wrap_log["-" * 40, color: :red]
+            log wrap_log["!! User Error, Please fix the issue and try again", color: :red]
+            log wrap_log["-" * 40, color: :red]
+            results[:user_error] = true
+            return [false, results]
+          end
           if remedies.delete? :init
             remedy = :init
             log wrap_log["Running terraform init ..."], depth: 2
-            exit_code, meta = PlanFormatter.run_tf_init
+            exit_code, meta = InitFormatter.run_tf_init
             print_errors_and_warnings(meta)
-            remedies = PlanFormatter.init_status_to_remedies(exit_code, meta)
+            remedies = InitFormatter.init_status_to_remedies(exit_code, meta)
             status, r_results = process_remedies(remedies, from: from, level: level + 1)
             results.merge!(r_results)
             return [true, r_results] if status
@@ -170,9 +229,9 @@ module MuxTf
             remedy = :reconfigure
             log wrap_log["Running terraform init ..."], depth: 2
             result = remedy_retry_helper(from: :reconfigure, level: level + 1, attempt: retry_count) {
-              exit_code, meta = PlanFormatter.run_tf_init(reconfigure: true)
+              exit_code, meta = InitFormatter.run_tf_init(reconfigure: true)
               print_errors_and_warnings(meta)
-              remedies = PlanFormatter.init_status_to_remedies(exit_code, meta)
+              remedies = InitFormatter.init_status_to_remedies(exit_code, meta)
               [remedies, exit_code, meta]
             }
             unless result
@@ -180,15 +239,6 @@ module MuxTf
               return [false, result]
             end
           end
-          if remedies.delete? :user_error
-            remedy = :user_error
-            log wrap_log["user error encountered!", color: :red]
-            log wrap_log["-" * 40, color: :red]
-            log wrap_log["!! User Error, Please fix the issue and try again", color: :red]
-            log wrap_log["-" * 40, color: :red]
-            results[:user_error] = true
-            return [false, results]
-          end
           if remedies.delete? :auth
             remedy = :auth
             log wrap_log["auth error encountered!", color: :red]
@@ -221,13 +271,26 @@ module MuxTf
           cmd_loop(status)
         end
 
-        def cmd_loop(status = nil)
+        def cmd_loop(initial_status = nil)
           root_cmd = build_root_cmd
 
           folder_name = File.basename(Dir.getwd)
 
           puts root_cmd.help
 
+          status = initial_status
+
+          prompt = proc { format_prompt(folder_name, status) }
+
+          run_cmd_loop(prompt) do |cmd|
+            status = nil
+            throw(:stop, :no_input) if cmd == ""
+            args = Shellwords.split(cmd)
+            root_cmd.run(args, {}, hard_exit: false)
+          end
+        end
+
+        def format_prompt(folder_name, status)
           prompt = "#{folder_name} => "
           case status
           when :error, :unknown
@@ -235,12 +298,7 @@ module MuxTf
           when :changes
             prompt = "[#{pastel.yellow(status.to_s)}] #{prompt}"
           end
-
-          run_cmd_loop(prompt) do |cmd|
-            throw(:stop, :no_input) if cmd == ""
-            args = Shellwords.split(cmd)
-            root_cmd.run(args, {}, hard_exit: false)
-          end
+          prompt
         end
 
         def build_root_cmd
@@ -261,32 +319,19 @@ module MuxTf
           root_cmd
         end
 
-        def plan_summary_text
-          plan_filename = PlanFilenameGenerator.for_path
-          if File.exist?("#{plan_filename}.txt") && File.mtime("#{plan_filename}.txt").to_f >= File.mtime(plan_filename).to_f
-            File.read("#{plan_filename}.txt")
-          else
-            puts "Inspecting Changes ... #{plan_filename}"
-            data = PlanUtils.text_version_of_plan_show(plan_filename)
-            File.write("#{plan_filename}.txt", data)
-            data
-          end
-        end
-
         def plan_details_cmd
           define_cmd("details", summary: "Show Plan Details") do |_opts, _args, _cmd|
-            puts plan_summary_text
+            plan_filename = PlanFilenameGenerator.for_path
+            plan = PlanSummaryHandler.from_file(plan_filename)
 
-            unless ENV["JSON_PLAN"]
-              log "Printing Plan Summary ...", depth: 1
+            log plan.plan_text_output
 
-              plan_filename = PlanFilenameGenerator.for_path
-              plan = PlanSummaryHandler.from_file(plan_filename)
-              plan.simple_summary do |line|
-                log line
-              end
+            log ""
+
+            log "Resource Summary:"
+            plan.simple_summary do |line|
+              log line
             end
-            # puts plan_summary_text if ENV["JSON_PLAN"]
           end
         end
 
@@ -315,7 +360,7 @@ module MuxTf
           define_cmd("force-unlock", summary: "Force unlock state after encountering a lock error!") do # rubocop:disable Metrics/BlockLength
             prompt = TTY::Prompt.new(interrupt: :noop)
 
-            lock_info = @last_lock_info
+            lock_info = @plan_command.last_lock_info
 
             if lock_info
               table = TTY::Table.new(header: %w[Field Value])
@@ -358,7 +403,7 @@ module MuxTf
 
         def init_cmd
           define_cmd("init", summary: "Re-run init") do |_opts, _args, _cmd|
-            exit_code, meta = PlanFormatter.run_tf_init
+            exit_code, meta = InitFormatter.run_tf_init
             print_errors_and_warnings(meta)
             if exit_code != 0
               log meta.inspect unless meta.empty?
@@ -379,7 +424,7 @@ module MuxTf
 
         def reconfigure_cmd
           define_cmd("reconfigure", summary: "Reconfigure modules/plguins") do |_opts, _args, _cmd|
-            exit_code, meta = PlanFormatter.run_tf_init(reconfigure: true)
+            exit_code, meta = InitFormatter.run_tf_init(reconfigure: true)
             print_errors_and_warnings(meta)
             if exit_code != 0
               log meta.inspect unless meta.empty?
@@ -411,7 +456,7 @@ module MuxTf
         end
 
         def run_upgrade
-          exit_code, meta = PlanFormatter.run_tf_init(upgrade: true)
+          exit_code, meta = InitFormatter.run_tf_init(upgrade: true)
           print_errors_and_warnings(meta)
           case exit_code
           when 0

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