mux_tf 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd2c3c9fe3713fedf24899d07fe227d731d6331eef42356934bd3ba2a0f3b68b
-  data.tar.gz: 878d5e65dbfe4335b58f2867be76d5d7f91d52702338695c2b0c89d98c0dc615
+  metadata.gz: ab68c9969748e0246a48cb2bf53876b0b2f47993b021017e1e9bb31782a7e4b4
+  data.tar.gz: 63fb2194ba923f3c30c9480f50946c550e85ea9e7e1988fdcc1764cbe7666f6a
 SHA512:
-  metadata.gz: 91cf73ffb77f5282ebf0bb4186d9eb8ba51a75b58b2767d139c81ecced720cc94a1852ec4bd0d038ec203063500b24ef12712b4e54295c0d308991e9fe393340
-  data.tar.gz: 55ea5b19015b5266cec12962a25b41d8a29ea090cab7a9de6381147a70c90c214b995c085862bc0e084582711c99e375f8a7d07871e1bf8c0f8a63f55f7bdba4
+  metadata.gz: e8d1442c6cff1c7c0828347176b1cc0a49fa28fb5a27e0212e730e3bf176fc4a072ba247e9cbf6d248c488fb1c62ffc6a71181dbde47e0b35a759b798ded6886
+  data.tar.gz: 3d85fc7be2b58bd815060145c33bccf7dc5814a5ee3a052f5adc6a4c7512792e290f0b1bb26faa07d4f950aab81036bcf9c09b91c2a3a20878fcd70601bd2044

data/lib/mux_tf/cli/current.rb

@@ -4,7 +4,7 @@ require "bundler"
 
 module MuxTf
   module Cli
-    module Current
+    module Current # rubocop:disable Metrics/ModuleLength
       extend TerraformHelpers
       extend PiotrbCliUtils::Util
       extend PiotrbCliUtils::CriCommandSupport
@@ -32,19 +32,16 @@ module MuxTf
             return launch_cmd_loop(:error) unless upgrade_status == :ok
           end
 
-          plan_status, @plan_meta = create_plan(plan_filename)
+          plan_status = run_plan
 
           case plan_status
           when :ok
-            log "no changes, exiting", depth: 1
+            log "exiting", depth: 1
           when :error
-            log "something went wrong", depth: 1
             launch_cmd_loop(plan_status)
-          when :changes
-            log "Printing Plan Summary ...", depth: 1
-            pretty_plan_summary(plan_filename)
+          when :changes # rubocop:disable Lint/DuplicateBranch
             launch_cmd_loop(plan_status)
-          when :unknown
+          when :unknown # rubocop:disable Lint/DuplicateBranch
             launch_cmd_loop(plan_status)
           end
         end
@@ -68,28 +65,45 @@ module MuxTf
 
         def run_validate
           remedies = PlanFormatter.process_validation(validate)
-          process_remedies(remedies)
+          status, _results = process_remedies(remedies)
+          status
         end
 
-        def process_remedies(remedies)
+        def process_remedies(remedies, retry_count: 0) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+          results = {}
+          if retry_count > 5
+            log "giving up because retry_count: #{retry_count}", depth: 1
+            log "unprocessed remedies: #{remedies.to_a}", depth: 1
+            return [false, results]
+          end
           if remedies.delete? :init
-            log "Running terraform init ...", depth: 2
+            log "[remedy] Running terraform init ...", depth: 2
             remedies = PlanFormatter.init_status_to_remedies(*PlanFormatter.run_tf_init)
-            if process_remedies(remedies)
+            status, r_results = process_remedies(remedies)
+            results.merge!(r_results)
+            if status
               remedies = PlanFormatter.process_validation(validate)
-              return false unless process_remedies(remedies)
+              return [false, results] unless process_remedies(remedies)
             end
           end
+          if remedies.delete?(:plan)
+            log "[remedy] Running terraform plan ...", depth: 2
+            plan_status = run_plan(retry_count: retry_count)
+            results[:plan_status] = plan_status
+            return [false, results] unless [:ok, :changes].include?(plan_status)
+          end
           if remedies.delete? :reconfigure
-            log "Running terraform init ...", depth: 2
+            log "[remedy] Running terraform init ...", depth: 2
             remedies = PlanFormatter.init_status_to_remedies(*PlanFormatter.run_tf_init(reconfigure: true))
-            return false unless process_remedies(remedies)
+            status, r_results = process_remedies(remedies)
+            results.merge!(r_results)
+            return [false, results] unless status
           end
           unless remedies.empty?
             log "unprocessed remedies: #{remedies.to_a}", depth: 1
-            return false
+            return [false, results]
           end
-          true
+          [true, results]
         end
 
         def validate
@@ -268,20 +282,68 @@ module MuxTf
           end
         end
 
-        def run_plan(targets: [])
+        def print_errors_and_warnings # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+          message = []
+          message << Paint["#{@plan_meta[:warnings].length} Warnings", :yellow] if @plan_meta[:warnings]
+          message << Paint["#{@plan_meta[:errors].length} Errors", :red] if @plan_meta[:errors]
+          if message.length.positive?
+            log ""
+            log "Encountered: #{message.join(' and ')}"
+            log ""
+          end
+
+          @plan_meta[:warnings]&.each do |warning|
+            log "-" * 20
+            log Paint["Warning: #{warning[:message]}", :yellow]
+            warning[:body]&.each do |line|
+              log Paint[line, :yellow], depth: 1
+            end
+            log ""
+          end
+
+          @plan_meta[:errors]&.each do |error|
+            log "-" * 20
+            log Paint["Error: #{error[:message]}", :red]
+            error[:body]&.each do |line|
+              log Paint[line, :red], depth: 1
+            end
+            log ""
+          end
+
+          return unless message.length.positive?
+
+          log ""
+        end
+
+        def detect_remedies_from_plan
+          remedies = Set.new
+          @plan_meta[:errors]&.each do |error|
+            remedies << :plan if error[:message].include?("timeout while waiting for plugin to start")
+          end
+          remedies
+        end
+
+        def run_plan(targets: [], retry_count: 0)
           plan_status, @plan_meta = create_plan(plan_filename, targets: targets)
 
           case plan_status
           when :ok
             log "no changes", depth: 1
           when :error
-            log "something went wrong", depth: 1
+            # log "something went wrong", depth: 1
+            print_errors_and_warnings
+            remedies = detect_remedies_from_plan
+            status, results = process_remedies(remedies, retry_count: retry_count)
+            plan_status = results[:plan_status] if status
           when :changes
             log "Printing Plan Summary ...", depth: 1
             pretty_plan_summary(plan_filename)
           when :unknown
             # nothing
           end
+
+          print_errors_and_warnings
+
           plan_status
         end
 
@@ -292,8 +354,6 @@ module MuxTf
             [:ok, meta]
           when 1
             [:error, meta]
-          # when 2
-          #   [:changes, meta]
           else
             log Paint["terraform init upgrade exited with an unknown exit code: #{exit_code}", :yellow]
             [:unknown, meta]

data/lib/mux_tf/cli.rb

@@ -2,6 +2,8 @@
 
 module MuxTf
   module Cli
+    extend PiotrbCliUtils::Util
+
     def self.run(mode, args)
       case mode
       when :mux

data/lib/mux_tf/plan_formatter.rb

@@ -9,13 +9,11 @@ module MuxTf
       def pretty_plan(filename, targets: []) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         pastel = Pastel.new
 
-        once = OnceHelper.new
-
         meta = {}
 
         parser = StatefulParser.new(normalizer: pastel.method(:strip))
         parser.state(:info, /^Acquiring state lock/)
-        parser.state(:error, /(╷|Error locking state|Error:)/, [:none, :blank, :info, :reading])
+        parser.state(:error, /(Error locking state|Error:)/, [:none, :blank, :info, :reading])
         parser.state(:reading, /: (Reading...|Read complete after)/, [:none, :info, :reading])
         parser.state(:none, /^$/, [:reading])
         parser.state(:refreshing, /^.+: Refreshing state... \[id=/, [:none, :info, :reading])
@@ -23,19 +21,30 @@ module MuxTf
                      [:none, :blank, :info, :reading])
         parser.state(:refresh_done, /^----------+$/, [:refreshing])
         parser.state(:refresh_done, /^$/, [:refreshing])
+
+        parser.state(:output_info, /^Changes to Outputs:$/, [:refresh_done])
+        parser.state(:refresh_done, /^$/, [:output_info])
+
         parser.state(:plan_info, /Terraform will perform the following actions:/, [:refresh_done, :none])
         parser.state(:plan_summary, /^Plan:/, [:plan_info])
 
         parser.state(:plan_legend, /^Terraform used the selected providers to generate the following execution$/)
         parser.state(:none, /^$/, [:plan_legend])
 
-        parser.state(:error_lock_info, /Lock Info/, [:error])
-        parser.state(:error, /^$/, [:error_lock_info])
+        parser.state(:error_lock_info, /Lock Info/, [:plan_error_error])
+
+        parser.state(:plan_error, /Planning failed. Terraform encountered an error while generating this plan./, [:refreshing, :refresh_done])
+        parser.state(:plan_error_block, /^╷/, [:plan_error, :none, :blank, :info, :reading])
+        parser.state(:plan_error_warning, /^│ Warning: /, [:plan_error_block])
+        parser.state(:plan_error_error, /^│ Error: /, [:plan_error_block])
+        parser.state(:plan_error, /^╵/, [:plan_error_warning, :plan_error_error, :plan_error_block, :error_lock_info])
 
-        parser.state(:plan_error, /^╷|Error: /, [:refreshing, :refresh_done])
+        last_state = nil
 
         status = tf_plan(out: filename, detailed_exitcode: true, compact_warnings: true, targets: targets) { |raw_line|
           parser.parse(raw_line.rstrip) do |state, line|
+            first_in_state = last_state != state
+
             case state
             when :none
               if line.blank?
@@ -62,39 +71,77 @@ module MuxTf
               else
                 p [state, line]
               end
-            when :error
-              meta["error"] = "lock"
-              log Paint[line, :red], depth: 2
+            when :plan_error_block
+              meta[:current_error] = {
+                type: :unknown,
+                body: []
+              }
+            when :plan_error_warning, :plan_error_error
+              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 :plan_error
-              once.for(state).once do puts end
-              meta["error"] = "refresh"
-              log Paint[line, :red], depth: 2
+              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)
+              when ""
+                # skip empty line
+              when /Releasing state lock. This may take a few moments"/
+                log line, depth: 2
+              when /Planning failed./ # rubocop:disable Lint/DuplicateBranch
+                log line, depth: 2
+              else
+                p [state, line]
+              end
             when :error_lock_info
+              meta["error"] = "lock"
               meta[$LAST_MATCH_INFO[1]] = $LAST_MATCH_INFO[2] if line =~ /([A-Z]+\S+)+:\s+(.+)$/
-              log Paint[line, :red], depth: 2
+              clean_line = pastel.strip(line).gsub(/^│ /, "")
+              if clean_line == ""
+                meta[:current_error][:body] << clean_line if meta[:current_error][:body].last != ""
+              else
+                meta[:current_error][:body] << clean_line
+              end
+              # log Paint[line, :red], depth: 2
             when :refreshing
-              once.for(state).once {
+              if first_in_state
                 log "Refreshing state ", depth: 2, newline: false
-              }.otherwise {
+              else
                 print "."
-              }
+              end
             when :plan_legend
-              once.for(state).once do puts end
+              puts if first_in_state
               log line, depth: 2
             when :refresh_done
-              once.for(state).once {
-                puts
-              }.otherwise {
-                # nothing
-              }
+              puts if first_in_state
             when :plan_info # rubocop:disable Lint/DuplicateBranch
-              once.for(state).once do puts end
+              puts if first_in_state
+              log line, depth: 2
+            when :output_info # rubocop:disable Lint/DuplicateBranch
+              puts if first_in_state
               log line, depth: 2
             when :plan_summary
               log line, depth: 2
             else
               p [state, pastel.strip(line)]
             end
+            last_state = state
           end
         }
         [status.status, meta]
@@ -264,6 +311,8 @@ module MuxTf
               remedies << :init
             elsif /there is no package for .+ cached in/.match?(dinfo["summary"]) # rubocop:disable Lint/DuplicateBranch
               remedies << :init
+            elsif dinfo["detail"]&.include?("timeout while waiting for plugin to start") # rubocop:disable Lint/DuplicateBranch
+              remedies << :init
             else
               log dinfo["detail"], depth: 4 if dinfo["detail"]
               log format_validation_range(dinfo["range"], color), depth: 4 if dinfo["range"]

data/lib/mux_tf/plan_summary_handler.rb

@@ -239,7 +239,7 @@ module MuxTf
         throw :abort, "nothing selected"
       else
         log "Re-running apply with the selected resources ..."
-        run_plan(targets: result)
+        MuxTf::Cli::Current.run_plan(targets: result)
       end
     end
 
@@ -263,36 +263,6 @@ module MuxTf
       end
     end
 
-    def run_plan(targets: [])
-      plan_filename = MuxTf::Cli::Current.plan_filename
-      plan_status, @plan_meta = create_plan(plan_filename, targets: targets)
-
-      case plan_status
-      when :ok
-        log "no changes", depth: 1
-      when :error
-        log "something went wrong", depth: 1
-      when :changes
-        log "Printing Plan Summary ...", depth: 1
-        pretty_plan_summary(plan_filename)
-      when :unknown
-        # nothing
-      end
-      plan_status
-    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
-
     def prune_unchanged_deps(_parts)
       valid_addresses = resource_parts.map { |part| part[:address] }
 

data/lib/mux_tf/terraform_helpers.rb

@@ -3,6 +3,7 @@
 module MuxTf
   module TerraformHelpers
     include PiotrbCliUtils::ShellHelpers
+    include PiotrbCliUtils::Util
 
     ResultStruct = Struct.new("TerraformResponse", :status, :success?, :output, :parsed_output, keyword_init: true)
 

data/lib/mux_tf/tmux.rb

@@ -4,6 +4,8 @@ require "shellwords"
 
 module MuxTf
   module Tmux
+    extend PiotrbCliUtils::Util
+
     class << self
       def session_running?(name)
         tmux("has-session -t #{name.inspect} 2>/dev/null", raise_on_error: false)

data/lib/mux_tf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MuxTf
-  VERSION = "0.11.0"
+  VERSION = "0.13.0"
 end

data/lib/mux_tf.rb

@@ -23,7 +23,6 @@ require "dotenv"
 
 require_relative "./mux_tf/version"
 require_relative "./mux_tf/plan_filename_generator"
-require_relative "./mux_tf/once_helper"
 require_relative "./mux_tf/resource_tokenizer"
 require_relative "./mux_tf/cli"
 require_relative "./mux_tf/tmux"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mux_tf
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Piotr Banasik
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-07-05 00:00:00.000000000 Z
+date: 2023-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -141,7 +141,6 @@ files:
 - lib/mux_tf/cli/current.rb
 - lib/mux_tf/cli/mux.rb
 - lib/mux_tf/cli/plan_summary.rb
-- lib/mux_tf/once_helper.rb
 - lib/mux_tf/plan_filename_generator.rb
 - lib/mux_tf/plan_formatter.rb
 - lib/mux_tf/plan_summary_handler.rb

data/lib/mux_tf/once_helper.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module MuxTf
-  class OnceHelper
-    # once = OnceHelper.new
-    # once.for(:phase).once { ... }.otherwise { ... }
-
-    class StateEvaluator
-      def initialize(once_helper, new_state)
-        if once_helper.state == new_state
-          @path = :otherwise
-        else
-          once_helper.state = new_state
-          @path = :once
-        end
-      end
-
-      def once
-        yield if @path == :then
-        self
-      end
-
-      def otherwise
-        yield if @path == :otherwise
-        self
-      end
-    end
-
-    def initialize
-      @state = nil
-    end
-
-    attr_accessor :state
-
-    def for(new_state)
-      StateEvaluator.new(self, new_state)
-    end
-  end
-end