mux_tf 0.14.2 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69ba3f3800b5025923625f5c71be014ea5f2689d7bef6a6c309453ba8c77d37e
-  data.tar.gz: 64b7341a04b36e4daed8f63a4fca12e9a966d73269831ebb82faebfee4f4ee55
+  metadata.gz: 8f2bcb9ac31603cfab773175a4d81a7ab85e8cd44124dbdf7287234dd70537db
+  data.tar.gz: e50b7671fabc4ca94703452daef5fa3a0322f2f4fce103d2a1f02b05012e80a1
 SHA512:
-  metadata.gz: 8836967a52fb32c981eee5e84945e4ac3c20873f2a3e11af1137bd7442f7631464a37713cd1621571a6fbceba6e35efb9984ae9ec0e2257b91ee263044105a66
-  data.tar.gz: 5da9f6af5c83cc977c343650078cb27753ca6feeb82148d0662b3c9e7430a683547deda1a0c6411255c622664dbdb6d13a649d2fb91434eb3c2d3dd849fe69fe
+  metadata.gz: 5bf42a828264de913553c309f8acf9274175a7a2a2e9bc71f04534e91649ca6e91727ccf21677406f52d71331771935ead9f2011c4bb6b4780988174b7860767
+  data.tar.gz: abaaff54837201173a5c2ccaa796e2c501d48f4f8d72c46687b6275b6541037284be57dd8090c88d4d88c3eeee8983f68b03ce85e6a6bea4d98df914d1e62dbd

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Cli
+    module Current
+      class PlanCommand
+        include TerraformHelpers
+        include PiotrbCliUtils::CriCommandSupport
+        extend PiotrbCliUtils::Util
+
+        def plan_cmd
+          define_cmd("plan", summary: "Re-run plan") do |_opts, _args, _cmd|
+            run_validate && run_plan
+          end
+        end
+
+        # returns boolean true if succeeded
+        def run_validate(level: 1)
+          Current.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]
+          end
+        end
+
+        def run_plan(targets: [], level: 1, retry_count: 0)
+          plan_status, = Current.remedy_retry_helper(from: :plan, level: level, attempt: retry_count) {
+            @last_lock_info = nil
+
+            plan_filename = PlanFilenameGenerator.for_path
+
+            plan_status, meta = create_plan(plan_filename, targets: targets)
+
+            Current.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
+              plan_filename = PlanFilenameGenerator.for_path
+              pretty_plan_summary(plan_filename)
+            end
+            puts plan_summary_text if ENV["JSON_PLAN"]
+          when :unknown
+            # nothing
+          end
+
+          plan_status
+        end
+
+        private
+
+        def validate
+          log "Validating module ...", depth: 1
+          tf_validate # from Terraform Helpers
+        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 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 pretty_plan_summary(filename)
+          plan = PlanSummaryHandler.from_file(filename)
+          plan.simple_summary do |line|
+            log line, depth: 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mux_tf/cli/current.rb

@@ -11,10 +11,19 @@ module MuxTf
       extend PiotrbCliUtils::CmdLoop
       include Coloring
 
-      class << self # rubocop:disable Metrics/ClassLength
+      class << self
+        attr_accessor :plan_command
+
         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"
+
           if args[0] == "cli"
             cmd_loop
             return
@@ -36,17 +45,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 +66,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 +75,61 @@ 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|
+            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
+
+        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|
@@ -136,7 +162,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
@@ -160,6 +186,15 @@ module MuxTf
             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]
+            log wrap_log["-" * 40, color: :red]
+            log wrap_log["!! Auth Error, Please fix the issue and try again", color: :red]
+            log wrap_log["-" * 40, color: :red]
             return [false, results]
           end
 
@@ -174,27 +209,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"]
 
@@ -232,7 +246,7 @@ module MuxTf
         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)
@@ -240,6 +254,7 @@ 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 })
@@ -261,20 +276,26 @@ module MuxTf
         def plan_details_cmd
           define_cmd("details", summary: "Show Plan Details") do |_opts, _args, _cmd|
             puts plan_summary_text
-          end
-        end
 
-        def plan_cmd
-          define_cmd("plan", summary: "Re-run plan") do |_opts, _args, _cmd|
-            run_validate && run_plan
+            unless ENV["JSON_PLAN"]
+              log "Printing Plan Summary ...", depth: 1
+
+              plan_filename = PlanFilenameGenerator.for_path
+              plan = PlanSummaryHandler.from_file(plan_filename)
+              plan.simple_summary do |line|
+                log line
+              end
+            end
+            # puts plan_summary_text if ENV["JSON_PLAN"]
           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!"
@@ -335,6 +356,17 @@ module MuxTf
           end
         end
 
+        def init_cmd
+          define_cmd("init", summary: "Re-run init") do |_opts, _args, _cmd|
+            exit_code, meta = PlanFormatter.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
@@ -358,13 +390,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
@@ -373,99 +410,6 @@ 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
-        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
-
-            [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)
           print_errors_and_warnings(meta)
@@ -479,18 +423,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