mux_tf 0.15.0 → 0.17.0

data/lib/mux_tf/cli/current.rb

@@ -11,10 +11,64 @@ module MuxTf
       extend PiotrbCliUtils::CmdLoop
       include Coloring
 
-      class << self # rubocop:disable Metrics/ClassLength
+      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
+
+          init_tool_env
+
           if args[0] == "cli"
             cmd_loop
             return
@@ -27,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
@@ -36,17 +91,14 @@ module MuxTf
           folder_name = File.basename(Dir.getwd)
           log "Processing #{pastel.cyan(folder_name)} ..."
 
-          ENV["TF_IN_AUTOMATION"] = "1"
-          ENV["TF_INPUT"] = "0"
-
-          return launch_cmd_loop(:error) unless run_validate
+          return launch_cmd_loop(:error) unless @plan_command.run_validate
 
           if ENV["TF_UPGRADE"]
             upgrade_status, _upgrade_meta = run_upgrade
             return launch_cmd_loop(:error) unless upgrade_status == :ok
           end
 
-          plan_status = run_plan
+          plan_status = @plan_command.run_plan
 
           case plan_status
           when :ok
@@ -60,23 +112,6 @@ module MuxTf
           end
         end
 
-        def plan_filename
-          PlanFilenameGenerator.for_path
-        end
-
-        private
-
-        def version_check
-          return unless VersionCheck.has_updates?
-
-          log pastel.yellow("=" * 80)
-          log "New version of #{pastel.cyan('mux_tf')} is available!"
-          log "You are currently on version: #{pastel.yellow(VersionCheck.current_gem_version)}"
-          log "Latest version found is: #{pastel.green(VersionCheck.latest_gem_version)}"
-          log "Run `#{pastel.green('gem install mux_tf')}` to update!"
-          log pastel.yellow("=" * 80)
-        end
-
         # block is expected to return a touple, the first element is a list of remedies
         # the rest are any additional results
         def remedy_retry_helper(from:, level: 1, attempt: 0, &block)
@@ -86,24 +121,65 @@ module MuxTf
               remedies, *results = block.call
               return results if remedies.empty?
 
-              remedy_status, _remedy_results = process_remedies(remedies, from: from, level: level)
+              remedy_status, remedy_results = process_remedies(remedies, from: from, level: level)
+              throw :abort, false if remedy_results[:user_error]
               return remedy_status if remedy_status
             end
             log "!! giving up because attempt: #{attempt}"
           end
         end
 
-        # returns boolean true if succeeded
-        def run_validate(level: 1)
-          remedy_retry_helper(from: :validate, level: level) do
-            validation_info = validate
-            PlanFormatter.print_validation_errors(validation_info)
-            remedies = PlanFormatter.process_validation(validation_info)
-            [remedies, validation_info]
+        def print_errors_and_warnings(meta)
+          message = []
+          message << pastel.yellow("#{meta[:warnings].length} Warnings") if meta[:warnings]
+          message << pastel.red("#{meta[:errors].length} Errors") if meta[:errors]
+          if message.length.positive?
+            log ""
+            log "Encountered: #{message.join(' and ')}"
+            log ""
+          end
+
+          meta[:warnings]&.each do |warning|
+            next if warning[:printed]
+
+            log "-" * 20
+            log pastel.yellow("Warning: #{warning[:message]}")
+            warning[:body]&.each do |line|
+              log pastel.yellow(line), depth: 1
+            end
+            log ""
           end
+
+          meta[:errors]&.each do |error|
+            next if error[:printed]
+
+            log "-" * 20
+            log pastel.red("Error: #{error[:message]}")
+            error[:body]&.each do |line|
+              log pastel.red(line), depth: 1
+            end
+            log ""
+          end
+
+          return unless message.length.positive?
+
+          log ""
+        end
+
+        private
+
+        def version_check
+          return unless VersionCheck.has_updates?
+
+          log pastel.yellow("=" * 80)
+          log "New version of #{pastel.cyan('mux_tf')} is available!"
+          log "You are currently on version: #{pastel.yellow(VersionCheck.current_gem_version)}"
+          log "Latest version found is: #{pastel.green(VersionCheck.latest_gem_version)}"
+          log "Run `#{pastel.green('gem install mux_tf')}` to update!"
+          log pastel.yellow("=" * 80)
         end
 
-        def process_remedies(remedies, from: nil, level: 1, retry_count: 0) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+        def process_remedies(remedies, from: nil, level: 1, retry_count: 0)
           remedies = remedies.dup
           remedy = nil
           wrap_log = lambda do |msg, color: nil|
@@ -123,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
@@ -136,7 +221,7 @@ module MuxTf
           if remedies.delete?(:plan)
             remedy = :plan
             log wrap_log["Running terraform plan ..."], depth: 2
-            plan_status = run_plan(retry_count: retry_count)
+            plan_status = @plan_command.run_plan(retry_count: retry_count)
             results[:plan_status] = plan_status
             return [false, results] unless [:ok, :changes].include?(plan_status)
           end
@@ -144,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
@@ -154,14 +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]
-            return [false, results]
-          end
           if remedies.delete? :auth
             remedy = :auth
             log wrap_log["auth error encountered!", color: :red]
@@ -182,27 +259,6 @@ module MuxTf
           [true, results]
         end
 
-        def validate
-          log "Validating module ...", depth: 1
-          tf_validate.parsed_output
-        end
-
-        def create_plan(filename, targets: [])
-          log "Preparing Plan ...", depth: 1
-          exit_code, meta = PlanFormatter.pretty_plan(filename, targets: targets)
-          case exit_code
-          when 0
-            [:ok, meta]
-          when 1
-            [:error, meta]
-          when 2
-            [:changes, meta]
-          else
-            log pastel.yellow("terraform plan exited with an unknown exit code: #{exit_code}")
-            [:unknown, meta]
-          end
-        end
-
         def launch_cmd_loop(status)
           return if ENV["NO_CMD"]
 
@@ -215,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
@@ -229,18 +298,13 @@ 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
           root_cmd = define_cmd(nil)
 
-          root_cmd.add_command(plan_cmd)
+          root_cmd.add_command(@plan_command.plan_cmd)
           root_cmd.add_command(apply_cmd)
           root_cmd.add_command(shell_cmd)
           root_cmd.add_command(force_unlock_cmd)
@@ -248,41 +312,35 @@ module MuxTf
           root_cmd.add_command(reconfigure_cmd)
           root_cmd.add_command(interactive_cmd)
           root_cmd.add_command(plan_details_cmd)
+          root_cmd.add_command(init_cmd)
 
           root_cmd.add_command(exit_cmd)
           root_cmd.add_command(define_cmd("help", summary: "Show help for commands") { |_opts, _args, cmd| puts cmd.supercommand.help })
           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
-          end
-        end
+            plan_filename = PlanFilenameGenerator.for_path
+            plan = PlanSummaryHandler.from_file(plan_filename)
 
-        def plan_cmd
-          define_cmd("plan", summary: "Re-run plan") do |_opts, _args, _cmd|
-            run_validate && run_plan
+            log plan.plan_text_output
+
+            log ""
+
+            log "Resource Summary:"
+            plan.simple_summary do |line|
+              log line
+            end
           end
         end
 
         def apply_cmd
           define_cmd("apply", summary: "Apply the current plan") do |_opts, _args, _cmd|
+            plan_filename = PlanFilenameGenerator.for_path
             status = tf_apply(filename: plan_filename)
             if status.success?
-              plan_status = run_plan
+              plan_status = @plan_command.run_plan
               throw :stop, :done if plan_status == :ok
             else
               log "Apply Failed!"
@@ -302,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])
@@ -343,6 +401,17 @@ module MuxTf
           end
         end
 
+        def init_cmd
+          define_cmd("init", summary: "Re-run init") do |_opts, _args, _cmd|
+            exit_code, meta = InitFormatter.run_tf_init
+            print_errors_and_warnings(meta)
+            if exit_code != 0
+              log meta.inspect unless meta.empty?
+              log "Init Failed!"
+            end
+          end
+        end
+
         def upgrade_cmd
           define_cmd("upgrade", summary: "Upgrade modules/plguins") do |_opts, _args, _cmd|
             status, meta = run_upgrade
@@ -355,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?
@@ -366,13 +435,18 @@ module MuxTf
 
         def interactive_cmd
           define_cmd("interactive", summary: "Apply interactively") do |_opts, _args, _cmd|
+            plan_filename = PlanFilenameGenerator.for_path
             plan = PlanSummaryHandler.from_file(plan_filename)
             begin
-              abort_message = catch(:abort) { plan.run_interactive }
+              abort_message = catch(:abort) {
+                result = plan.run_interactive
+                log "Re-running apply with the selected resources ..."
+                @plan_command.run_plan(targets: result)
+              }
               if abort_message
                 log pastel.red("Aborted: #{abort_message}")
               else
-                run_plan
+                @plan_command.run_plan
               end
             rescue Exception => e # rubocop:disable Lint/RescueException
               log e.full_message
@@ -381,104 +455,8 @@ module MuxTf
           end
         end
 
-        def print_errors_and_warnings(meta) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
-          message = []
-          message << pastel.yellow("#{meta[:warnings].length} Warnings") if meta[:warnings]
-          message << pastel.red("#{meta[:errors].length} Errors") if meta[:errors]
-          if message.length.positive?
-            log ""
-            log "Encountered: #{message.join(' and ')}"
-            log ""
-          end
-
-          meta[:warnings]&.each do |warning|
-            log "-" * 20
-            log pastel.yellow("Warning: #{warning[:message]}")
-            warning[:body]&.each do |line|
-              log pastel.yellow(line), depth: 1
-            end
-            log ""
-          end
-
-          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
-
-          return unless message.length.positive?
-
-          log ""
-        end
-
-        def detect_remedies_from_plan(meta)
-          remedies = Set.new
-          meta[:errors]&.each do |error|
-            remedies << :plan if error[:message].include?("timeout while waiting for plugin to start")
-          end
-          remedies << :unlock if lock_error?(meta)
-          remedies << :auth if meta[:need_auth]
-          remedies
-        end
-
-        def lock_error?(meta)
-          meta && meta["error"] == "lock"
-        end
-
-        def extract_lock_info(meta)
-          {
-            lock_id: meta["ID"],
-            operation: meta["Operation"],
-            who: meta["Who"],
-            created: meta["Created"]
-          }
-        end
-
-        def run_plan(targets: [], level: 1, retry_count: 0)
-          plan_status, = remedy_retry_helper(from: :plan, level: level, attempt: retry_count) {
-            @last_lock_info = nil
-
-            plan_status, meta = create_plan(plan_filename, targets: targets)
-
-            print_errors_and_warnings(meta)
-
-            remedies = detect_remedies_from_plan(meta)
-
-            if remedies.include?(:unlock)
-              @last_lock_info = extract_lock_info(meta)
-              throw :abort, [plan_status, meta]
-            end
-
-            throw :abort, [plan_status, meta] if remedies.include?(:auth)
-
-            [remedies, plan_status, meta]
-          }
-
-          case plan_status
-          when :ok
-            log "no changes", depth: 1
-          when :error
-            log "something went wrong", depth: 1
-          when :changes
-            unless ENV["JSON_PLAN"]
-              log "Printing Plan Summary ...", depth: 1
-              pretty_plan_summary(plan_filename)
-            end
-            puts plan_summary_text if ENV["JSON_PLAN"]
-          when :unknown
-            # nothing
-          end
-
-          plan_status
-        end
-
-        public :run_plan
-
         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
@@ -490,18 +468,6 @@ module MuxTf
             [:unknown, meta]
           end
         end
-
-        def pretty_plan_summary(filename)
-          plan = PlanSummaryHandler.from_file(filename)
-          plan.flat_summary.each do |line|
-            log line, depth: 2
-          end
-          plan.output_summary.each do |line|
-            log line, depth: 2
-          end
-          log "", depth: 2
-          log plan.summary, depth: 2
-        end
       end
     end
   end