mux_tf 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab68c9969748e0246a48cb2bf53876b0b2f47993b021017e1e9bb31782a7e4b4
-  data.tar.gz: 63fb2194ba923f3c30c9480f50946c550e85ea9e7e1988fdcc1764cbe7666f6a
+  metadata.gz: f9a03af7a131fd34e58d5fb27d3c578154f49246634a684980e6ebc16aa28d08
+  data.tar.gz: d093d1604dabbeb1aed8ef5b1ebc3e33a0b5e3575602f7b3802796b2b51f7a7a
 SHA512:
-  metadata.gz: e8d1442c6cff1c7c0828347176b1cc0a49fa28fb5a27e0212e730e3bf176fc4a072ba247e9cbf6d248c488fb1c62ffc6a71181dbde47e0b35a759b798ded6886
-  data.tar.gz: 3d85fc7be2b58bd815060145c33bccf7dc5814a5ee3a052f5adc6a4c7512792e290f0b1bb26faa07d4f950aab81036bcf9c09b91c2a3a20878fcd70601bd2044
+  metadata.gz: 7809b83e63a8aa17671ef6fbaac79a09cd7aa8216fdd1ccd390f2e32ee0b4ec0a85e4f6653d4c4bbbafcb99d47076413a9135f970f4d4c0f7f8608b2e8858f5f
+  data.tar.gz: c9dd73ed72236b568c7bbdc34ede9701e1d1db94403ccd2e84ee611cd58500e73810f50c9c0bdd6817c2ef7f8bd5d504fd945d86d340db95d9246e797376efb4

data/exe/tf_current

@@ -11,6 +11,8 @@ begin
 rescue Interrupt
   warn "\nInterrupted"
   exit 1
+rescue SystemExit => e
+  exit e.status
 rescue Exception => e # rubocop:disable Lint/RescueException
   warn e.full_message
   warn "<press enter>"

data/exe/tf_mux

@@ -11,6 +11,8 @@ begin
 rescue Interrupt
   warn "\nInterrupted"
   exit 1
+rescue SystemExit => e
+  exit e.status
 rescue Exception => e # rubocop:disable Lint/RescueException
   warn e.full_message
   warn "<press enter>"

data/exe/tf_plan_summary

@@ -11,6 +11,8 @@ begin
 rescue Interrupt
   warn "\nInterrupted"
   exit 1
+rescue SystemExit => e
+  exit e.status
 rescue Exception => e # rubocop:disable Lint/RescueException
   warn e.full_message
   warn "<press enter>"

data/lib/deps.rb

@@ -2,6 +2,15 @@
 
 require "bundler/inline"
 
-gemfile do
+dep_def = proc do
   gemspec(path: File.join(__dir__, ".."))
 end
+
+begin
+  gemfile(&dep_def)
+rescue Bundler::GemNotFound
+  gemfile(true) do
+    source "https://rubygems.org"
+    instance_exec(&dep_def)
+  end
+end

data/lib/mux_tf/cli/current.rb

@@ -9,8 +9,9 @@ module MuxTf
       extend PiotrbCliUtils::Util
       extend PiotrbCliUtils::CriCommandSupport
       extend PiotrbCliUtils::CmdLoop
+      include Coloring
 
-      class << self
+      class << self # rubocop:disable Metrics/ClassLength
         def run(args)
           version_check
 
@@ -19,8 +20,21 @@ module MuxTf
             return
           end
 
+          unless args.empty?
+            root_cmd = build_root_cmd
+            valid_commands = root_cmd.subcommands.map(&:name)
+
+            if args[0] && valid_commands.include?(args[0])
+              stop_reason = catch(:stop) {
+                root_cmd.run(args, {}, hard_exit: true)
+              }
+              log pastel.red("Stopped: #{stop_reason}") if stop_reason
+              return
+            end
+          end
+
           folder_name = File.basename(Dir.getwd)
-          log "Processing #{Paint[folder_name, :cyan]} ..."
+          log "Processing #{pastel.cyan(folder_name)} ..."
 
           ENV["TF_IN_AUTOMATION"] = "1"
           ENV["TF_INPUT"] = "0"
@@ -55,52 +69,102 @@ module MuxTf
         def version_check
           return unless VersionCheck.has_updates?
 
-          log Paint["=" * 80, :yellow]
-          log "New version of #{Paint['mux_tf', :cyan]} is available!"
-          log "You are currently on version: #{Paint[VersionCheck.current_gem_version, :yellow]}"
-          log "Latest version found is: #{Paint[VersionCheck.latest_gem_version, :green]}"
-          log "Run `#{Paint['gem install mux_tf', :green]}` to update!"
-          log Paint["=" * 80, :yellow]
+          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 run_validate
-          remedies = PlanFormatter.process_validation(validate)
-          status, _results = process_remedies(remedies)
-          status
+        # 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)
+          catch(:abort) do
+            until attempt > 1
+              attempt += 1
+              remedies, *results = block.call
+              return results if remedies.empty?
+
+              remedy_status, _remedy_results = process_remedies(remedies, from: from, level: level)
+              return unless 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]
+          end
         end
 
-        def process_remedies(remedies, retry_count: 0) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+        def process_remedies(remedies, from: nil, level: 1, retry_count: 0) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+          remedies = remedies.dup
+          remedy = nil
+          wrap_log = lambda do |msg, color: nil|
+            [
+              from ? pastel.cyan("#{from} -> ") : nil,
+              pastel.cyan(remedy ? "[remedy: #{remedy}]" : "[process remedies]"),
+              " ",
+              color ? pastel.decorate(msg, color) : msg,
+              " ",
+              level > 1 ? pastel.cyan("[lv #{level}]") : nil,
+              retry_count.positive? ? pastel.cyan("[try #{retry_count}]") : nil
+            ].compact.join
+          end
           results = {}
           if retry_count > 5
-            log "giving up because retry_count: #{retry_count}", depth: 1
-            log "unprocessed remedies: #{remedies.to_a}", depth: 1
+            log wrap_log["giving up because retry_count: #{retry_count}", color: :yellow], depth: 1
+            log wrap_log["unprocessed remedies: #{remedies.to_a}", color: :red], depth: 1
             return [false, results]
           end
           if remedies.delete? :init
-            log "[remedy] Running terraform init ...", depth: 2
-            remedies = PlanFormatter.init_status_to_remedies(*PlanFormatter.run_tf_init)
-            status, r_results = process_remedies(remedies)
+            remedy = :init
+            log wrap_log["Running terraform init ..."], depth: 2
+            exit_code, meta = PlanFormatter.run_tf_init
+            print_errors_and_warnings(meta)
+            remedies = PlanFormatter.init_status_to_remedies(exit_code, meta)
+            status, r_results = process_remedies(remedies, from: from, level: level + 1)
             results.merge!(r_results)
-            if status
-              remedies = PlanFormatter.process_validation(validate)
-              return [false, results] unless process_remedies(remedies)
-            end
+            return [true, r_results] if status
           end
           if remedies.delete?(:plan)
-            log "[remedy] Running terraform plan ...", depth: 2
+            remedy = :plan
+            log wrap_log["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 "[remedy] Running terraform init ...", depth: 2
-            remedies = PlanFormatter.init_status_to_remedies(*PlanFormatter.run_tf_init(reconfigure: true))
-            status, r_results = process_remedies(remedies)
-            results.merge!(r_results)
-            return [false, results] unless status
+            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)
+              print_errors_and_warnings(meta)
+              remedies = PlanFormatter.init_status_to_remedies(exit_code, meta)
+              [remedies, exit_code, meta]
+            }
+            unless result
+              log wrap_log["Failed", color: :red], depth: 2
+              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
           unless remedies.empty?
-            log "unprocessed remedies: #{remedies.to_a}", depth: 1
+            remedy = nil
+            log wrap_log["Unprocessed remedies: #{remedies.to_a}", color: :red], depth: 1 if level == 1
             return [false, results]
           end
           [true, results]
@@ -122,7 +186,7 @@ module MuxTf
           when 2
             [:changes, meta]
           else
-            log Paint["terraform plan exited with an unknown exit code: #{exit_code}", :yellow]
+            log pastel.yellow("terraform plan exited with an unknown exit code: #{exit_code}")
             [:unknown, meta]
           end
         end
@@ -132,9 +196,9 @@ module MuxTf
 
           case status
           when :error, :unknown
-            log Paint["Dropping to command line so you can fix the issue!", :red]
+            log pastel.red("Dropping to command line so you can fix the issue!")
           when :changes
-            log Paint["Dropping to command line so you can review the changes.", :yellow]
+            log pastel.yellow("Dropping to command line so you can review the changes.")
           end
           cmd_loop(status)
         end
@@ -149,9 +213,9 @@ module MuxTf
           prompt = "#{folder_name} => "
           case status
           when :error, :unknown
-            prompt = "[#{Paint[status.to_s, :red]}] #{prompt}"
+            prompt = "[#{pastel.red(status.to_s)}] #{prompt}"
           when :changes
-            prompt = "[#{Paint[status.to_s, :yellow]}] #{prompt}"
+            prompt = "[#{pastel.yellow(status.to_s)}] #{prompt}"
           end
 
           run_cmd_loop(prompt) do |cmd|
@@ -171,11 +235,31 @@ module MuxTf
           root_cmd.add_command(upgrade_cmd)
           root_cmd.add_command(reconfigure_cmd)
           root_cmd.add_command(interactive_cmd)
+          root_cmd.add_command(plan_details_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
+
         def plan_cmd
           define_cmd("plan", summary: "Re-run plan") do |_opts, _args, _cmd|
             run_validate && run_plan
@@ -196,28 +280,30 @@ module MuxTf
 
         def shell_cmd
           define_cmd("shell", summary: "Open your default terminal in the current folder") do |_opts, _args, _cmd|
-            log Paint["Launching shell ...", :yellow]
-            log Paint["When it exits you will be back at this prompt.", :yellow]
+            log pastel.yellow("Launching shell ...")
+            log pastel.yellow("When it exits you will be back at this prompt.")
             system ENV.fetch("SHELL")
           end
         end
 
         def force_unlock_cmd
-          define_cmd("force-unlock", summary: "Force unlock state after encountering a lock error!") do
+          define_cmd("force-unlock", summary: "Force unlock state after encountering a lock error!") do # rubocop:disable Metrics/BlockLength
             prompt = TTY::Prompt.new(interrupt: :noop)
 
-            table = TTY::Table.new(header: %w[Field Value])
-            table << ["Lock ID", @plan_meta["ID"]]
-            table << ["Operation", @plan_meta["Operation"]]
-            table << ["Who", @plan_meta["Who"]]
-            table << ["Created", @plan_meta["Created"]]
+            lock_info = @last_lock_info
+
+            if lock_info
+              table = TTY::Table.new(header: %w[Field Value])
+              table << ["Lock ID", lock_info[:lock_id]]
+              table << ["Operation", lock_info[:operation]]
+              table << ["Who", lock_info[:who]]
+              table << ["Created", lock_info[:created]]
 
-            puts table.render(:unicode, padding: [0, 1])
+              puts table.render(:unicode, padding: [0, 1])
 
-            if @plan_meta && @plan_meta["error"] == "lock"
               done = catch(:abort) {
-                if @plan_meta["Operation"] != "OperationTypePlan" && !prompt.yes?(
-                  "Are you sure you want to force unlock a lock for operation: #{@plan_meta['Operation']}",
+                if lock_info[:operation] != "OperationTypePlan" && !prompt.yes?(
+                  "Are you sure you want to force unlock a lock for operation: #{lock_info[:operation]}",
                   default: false
                 )
                   throw :abort
@@ -228,19 +314,19 @@ module MuxTf
                   default: false
                 )
 
-                status = tf_force_unlock(id: @plan_meta["ID"])
+                status = tf_force_unlock(id: lock_info[:lock_id])
                 if status.success?
                   log "Done!"
                 else
-                  log Paint["Failed with status: #{status}", :red]
+                  log pastel.red("Failed with status: #{status}")
                 end
 
                 true
               }
 
-              log Paint["Aborted", :yellow] unless done
+              log pastel.yellow("Aborted") unless done
             else
-              log Paint["No lock error or no plan ran!", :red]
+              log pastel.red("No lock error or no plan ran!")
             end
           end
         end
@@ -257,8 +343,9 @@ module MuxTf
 
         def reconfigure_cmd
           define_cmd("reconfigure", summary: "Reconfigure modules/plguins") do |_opts, _args, _cmd|
-            status, meta = PlanFormatter.run_tf_init(reconfigure: true)
-            if status != 0
+            exit_code, meta = PlanFormatter.run_tf_init(reconfigure: true)
+            print_errors_and_warnings(meta)
+            if exit_code != 0
               log meta.inspect unless meta.empty?
               log "Reconfigure Failed!"
             end
@@ -271,7 +358,7 @@ module MuxTf
             begin
               abort_message = catch(:abort) { plan.run_interactive }
               if abort_message
-                log Paint["Aborted: #{abort_message}", :red]
+                log pastel.red("Aborted: #{abort_message}")
               else
                 run_plan
               end
@@ -282,30 +369,30 @@ module MuxTf
           end
         end
 
-        def print_errors_and_warnings # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+        def print_errors_and_warnings(meta) # 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]
+          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
 
-          @plan_meta[:warnings]&.each do |warning|
+          meta[:warnings]&.each do |warning|
             log "-" * 20
-            log Paint["Warning: #{warning[:message]}", :yellow]
+            log pastel.yellow("Warning: #{warning[:message]}")
             warning[:body]&.each do |line|
-              log Paint[line, :yellow], depth: 1
+              log pastel.yellow(line), depth: 1
             end
             log ""
           end
 
-          @plan_meta[:errors]&.each do |error|
+          meta[:errors]&.each do |error|
             log "-" * 20
-            log Paint["Error: #{error[:message]}", :red]
+            log pastel.red("Error: #{error[:message]}")
             error[:body]&.each do |line|
-              log Paint[line, :red], depth: 1
+              log pastel.red(line), depth: 1
             end
             log ""
           end
@@ -315,47 +402,76 @@ module MuxTf
           log ""
         end
 
-        def detect_remedies_from_plan
+        def detect_remedies_from_plan(meta)
           remedies = Set.new
-          @plan_meta[:errors]&.each do |error|
+          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 run_plan(targets: [], retry_count: 0)
-          plan_status, @plan_meta = create_plan(plan_filename, targets: targets)
+        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
-            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
+            log "something went wrong", depth: 1
           when :changes
-            log "Printing Plan Summary ...", depth: 1
-            pretty_plan_summary(plan_filename)
+            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
 
-          print_errors_and_warnings
-
           plan_status
         end
 
+        public :run_plan
+
         def run_upgrade
           exit_code, meta = PlanFormatter.run_tf_init(upgrade: true)
+          print_errors_and_warnings(meta)
           case exit_code
           when 0
             [:ok, meta]
           when 1
             [:error, meta]
           else
-            log Paint["terraform init upgrade exited with an unknown exit code: #{exit_code}", :yellow]
+            log pastel.yellow("terraform init upgrade exited with an unknown exit code: #{exit_code}")
             [:unknown, meta]
           end
         end

data/lib/mux_tf/cli/plan_summary.rb

@@ -6,6 +6,7 @@ module MuxTf
       extend PiotrbCliUtils::Util
       extend PiotrbCliUtils::ShellHelpers
       extend TerraformHelpers
+      import Coloring
 
       class << self
         def run(args)
@@ -33,7 +34,7 @@ module MuxTf
 
           if options[:interactive]
             abort_message = catch(:abort) { plan.run_interactive }
-            log Paint["Aborted: #{abort_message}", :red] if abort_message
+            log pastel.red("Aborted: #{abort_message}") if abort_message
           else
             if options[:hierarchy]
               plan.nested_summary.each do |line|

data/lib/mux_tf/cli.rb

@@ -7,13 +7,13 @@ module MuxTf
     def self.run(mode, args)
       case mode
       when :mux
-        require_relative "./cli/mux"
+        require_relative "cli/mux"
         MuxTf::Cli::Mux.run(args)
       when :current
-        require_relative "./cli/current"
+        require_relative "cli/current"
         MuxTf::Cli::Current.run(args)
       when :plan_summary
-        require_relative "./cli/plan_summary"
+        require_relative "cli/plan_summary"
         MuxTf::Cli::PlanSummary.run(args)
       else
         fail_with "unhandled mode: #{mode.inspect}"

data/lib/mux_tf/coloring.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Coloring
+    def pastel
+      self.class.pastel
+    end
+
+    def self.included(other)
+      other.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def pastel
+        instance = Pastel.new
+        instance.alias_color(:orange, :yellow)
+        instance.alias_color(:gray, :bright_black)
+        instance.alias_color(:grey, :bright_black)
+        instance
+      end
+    end
+  end
+end