mux_tf 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 924f8b4cc0e90b4c636e3ffcc806c0e48036380ac81ee83b1dc21a437950e76e
-  data.tar.gz: 3bea784dc0db5091efa2dcba48c653b812d618b88c8dc04b997b59cc8e810e0c
+  metadata.gz: f9a03af7a131fd34e58d5fb27d3c578154f49246634a684980e6ebc16aa28d08
+  data.tar.gz: d093d1604dabbeb1aed8ef5b1ebc3e33a0b5e3575602f7b3802796b2b51f7a7a
 SHA512:
-  metadata.gz: 3dbd88ebf68ae0bb27116ce5b553a04668a746cfdd89ed1e646fc6f75961cf8c61d66f2a4ba46d0baaa17c6fdaa3b99704485632a5787a492037e75707e06b1a
-  data.tar.gz: bd9bf482078f080477f1871b02c256ad06b7bcb4e323adb8ee35fe056b9f8fd34bec4993c6b1611fac161b09b80db11c3d36395fdb42bef0d174e3ec666f8745
+  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

@@ -4,13 +4,14 @@ require "bundler"
 
 module MuxTf
   module Cli
-    module Current
+    module Current # rubocop:disable Metrics/ModuleLength
       extend TerraformHelpers
       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"
@@ -32,19 +46,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
@@ -58,38 +69,105 @@ 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)
-          process_remedies(remedies)
+        # 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
 
-        def process_remedies(remedies)
+        # 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, 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 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 "Running terraform init ...", depth: 2
-            remedies = PlanFormatter.init_status_to_remedies(*PlanFormatter.run_tf_init)
-            if process_remedies(remedies)
-              remedies = PlanFormatter.process_validation(validate)
-              return false unless process_remedies(remedies)
-            end
+            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)
+            return [true, r_results] if status
+          end
+          if remedies.delete?(:plan)
+            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 "Running terraform init ...", depth: 2
-            remedies = PlanFormatter.init_status_to_remedies(*PlanFormatter.run_tf_init(reconfigure: true))
-            return false unless process_remedies(remedies)
+            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
-            return false
+            remedy = nil
+            log wrap_log["Unprocessed remedies: #{remedies.to_a}", color: :red], depth: 1 if level == 1
+            return [false, results]
           end
-          true
+          [true, results]
         end
 
         def validate
@@ -108,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
@@ -118,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
@@ -135,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|
@@ -157,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
@@ -182,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
@@ -214,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
@@ -243,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
@@ -257,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
@@ -268,8 +369,78 @@ module MuxTf
           end
         end
 
-        def run_plan(targets: [])
-          plan_status, @plan_meta = create_plan(plan_filename, targets: targets)
+        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
@@ -277,25 +448,30 @@ module MuxTf
           when :error
             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
+
           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]
-          # when 2
-          #   [:changes, 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

@@ -2,16 +2,18 @@
 
 module MuxTf
   module Cli
+    extend PiotrbCliUtils::Util
+
     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