mux_tf 0.2.0 → 0.3.0

data/lib/mux_tf/plan_summary_handler.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module MuxTf
+  class PlanSummaryHandler
+    extend TerraformHelpers
+
+    def self.from_file(file)
+      data = data_from_file(file)
+      new data
+    end
+
+    def self.data_from_file(file)
+      if File.exist?("#{file}.json") && File.mtime("#{file}.json").to_f >= File.mtime(file).to_f
+        JSON.parse(File.read("#{file}.json"))
+      else
+        puts "Analyzing changes ..."
+        result = tf_show(file, json: true)
+        data = result.parsed_output
+        File.open("#{file}.json", "w") { |fh| fh.write(JSON.dump(data)) }
+        data
+      end
+    end
+
+    def self.from_data(data)
+      new(data)
+    end
+
+    def initialize(data)
+      @parts = []
+
+      data["resource_changes"].each do |v|
+        next unless v["change"]
+
+        case v["change"]["actions"]
+        when ["no-op"]
+          # do nothing
+        when ["create"]
+          parts << {
+            action: "create",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        when ["update"]
+          parts << {
+            action: "update",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        when ["delete"]
+          parts << {
+            action: "delete",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        when %w[delete create]
+          parts << {
+            action: "replace",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        when ["read"]
+          parts << {
+            action: "read",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        else
+          puts "[??] #{v["address"]}"
+          puts "UNKNOWN ACTIONS: #{v["change"]["actions"].inspect}"
+          puts "TODO: update plan_summary to support this!"
+        end
+      end
+
+      prune_unchanged_deps(parts)
+    end
+
+    def summary
+      summary = {}
+      parts.each do |part|
+        summary[part[:action]] ||= 0
+        summary[part[:action]] += 1
+      end
+      pieces = summary.map { |k, v|
+        color = color_for_action(k)
+        "#{Paint[v, :yellow]} to #{Paint[k, color]}"
+      }
+
+      "Plan Summary: #{pieces.join(Paint[", ", :gray])}"
+    end
+
+    def flat_summary
+      result = []
+      parts.each do |part|
+        result << "[#{format_action(part[:action])}] #{format_address(part[:address])}"
+      end
+      result
+    end
+
+    def nested_summary
+      result = []
+      parts = parts.deep_dup
+      until parts.empty?
+        part = parts.shift
+        if part[:deps] == []
+          indent = if part[:met_deps] && !part[:met_deps].empty?
+            "  "
+          else
+            ""
+          end
+          message = "[#{format_action(part[:action])}]#{indent} #{format_address(part[:address])}"
+          message += " - (needs: #{part[:met_deps].join(", ")})" if part[:met_deps]
+          result << message
+          parts.each do |ipart|
+            d = ipart[:deps].delete(part[:address])
+            if d
+              ipart[:met_deps] ||= []
+              ipart[:met_deps] << d
+            end
+          end
+        else
+          parts.unshift part
+        end
+      end
+      result
+    end
+
+    def run_interactive
+      prompt = TTY::Prompt.new
+      result = prompt.multi_select("Update resources:", per_page: 99, echo: false) { |menu|
+        parts.each do |part|
+          label = "[#{format_action(part[:action])}] #{format_address(part[:address])}"
+          menu.choice label, part[:address]
+        end
+      }
+
+      if !result.empty?
+        log "Re-running apply with the selected resources ..."
+        status = tf_apply(targets: result)
+        unless status.success?
+          log Paint["Failed! (#{status.status})", :red]
+          throw :abort, "Apply Failed! #{status.status}"
+        end
+      else
+        throw :abort, "nothing selected"
+      end
+    end
+
+    private
+
+    attr_reader :parts
+
+    def prune_unchanged_deps(parts)
+      valid_addresses = parts.map { |part| part[:address] }
+
+      parts.each do |part|
+        part[:deps].select! { |dep| valid_addresses.include?(dep) }
+      end
+    end
+
+    def find_deps(data, address)
+      result = []
+
+      m = address.match(/\[(.+)\]$/)
+      if m
+        address = m.pre_match
+        index = m[1][0] == '"' ? m[1].gsub(/^"(.+)"$/, '\1') : m[1].to_i
+      end
+
+      if data.dig("prior_state", "values", "root_module", "resources")
+        resource = data["prior_state"]["values"]["root_module"]["resources"].find { |resource|
+          address == resource["address"] && index == resource["index"]
+        }
+      end
+
+      result += resource["depends_on"] if resource && resource["depends_on"]
+
+      resource, parent_address = find_config(data["configuration"], "root_module", address, [])
+      if resource
+        deps = []
+        resource["expressions"].each do |_k, v|
+          deps << v["references"] if v.is_a?(Hash) && v["references"]
+        end
+        result += deps.map { |s| (parent_address + [s]).join(".") }
+      end
+
+      result
+    end
+
+    def find_config(module_root, module_name, address, parent_address)
+      module_info = if parent_address.empty?
+        module_root[module_name]
+      elsif module_root && module_root[module_name]
+        module_root[module_name]["module"]
+      else
+        {}
+      end
+
+      if m = address.match(/^module\.([^.]+)\./)
+        find_config(module_info["module_calls"], m[1], m.post_match, parent_address + ["module.#{m[1]}"])
+      else
+        if module_info["resources"]
+          resource = module_info["resources"].find { |resource|
+            address == resource["address"]
+          }
+        end
+        [resource, parent_address]
+      end
+    end
+
+    def color_for_action(action)
+      case action
+      when "create"
+        :green
+      when "update"
+        :yellow
+      when "delete"
+        :red
+      when "replace"
+        :red
+      when "read"
+        :cyan
+      else
+        :reset
+      end
+    end
+
+    def symbol_for_action(action)
+      case action
+      when "create"
+        "+"
+      when "update"
+        "~"
+      when "delete"
+        "-"
+      when "replace"
+        "±"
+      when "read"
+        ">"
+      else
+        action
+      end
+    end
+
+    def format_action(action)
+      color = color_for_action(action)
+      symbol = symbol_for_action(action)
+      Paint[symbol, color]
+    end
+
+    def format_address(address)
+      parts = address.split(".")
+      parts.each_with_index do |part, index|
+        parts[index] = Paint[part, :cyan] if index.odd?
+      end
+      parts.join(".")
+    end
+  end
+end

data/lib/mux_tf/terraform_helpers.rb

@@ -5,7 +5,7 @@ module MuxTf
     include PiotrbCliUtils::ShellHelpers
 
     def tf_force_unlock(id:)
-      run_terraform(tf_prepare_command(['force-unlock', '-force', id], need_auth: true))
+      run_terraform(tf_prepare_command(["force-unlock", "-force", id], need_auth: true))
     end
 
     def tf_apply(filename: nil, targets: [])
@@ -17,44 +17,44 @@ module MuxTf
         end
       end
 
-      cmd = tf_prepare_command(['apply', *args], need_auth: true)
+      cmd = tf_prepare_command(["apply", *args], need_auth: true)
       run_terraform(cmd)
     end
 
     def tf_validate
-      cmd = tf_prepare_command(['validate', '-json'], need_auth: true)
+      cmd = tf_prepare_command(["validate", "-json"], need_auth: true)
       capture_terraform(cmd, json: true)
     end
 
     def tf_init(input: nil, upgrade: nil, color: true, &block)
       args = []
       args << "-input=#{input.inspect}" unless input.nil?
-      args << '-upgrade' unless upgrade.nil?
-      args << '-no-color' unless color
+      args << "-upgrade" unless upgrade.nil?
+      args << "-no-color" unless color
 
-      cmd = tf_prepare_command(['init', *args], need_auth: true)
+      cmd = tf_prepare_command(["init", *args], need_auth: true)
       stream_or_run_terraform(cmd, &block)
     end
 
     def tf_plan(out:, color: true, detailed_exitcode: nil, compact_warnings: false, input: nil, &block)
       args = []
-      args += ['-out', out]
+      args += ["-out", out]
       args << "-input=#{input.inspect}" unless input.nil?
-      args << '-compact-warnings' if compact_warnings
-      args << '-no-color' unless color
-      args << '-detailed-exitcode' if detailed_exitcode
+      args << "-compact-warnings" if compact_warnings
+      args << "-no-color" unless color
+      args << "-detailed-exitcode" if detailed_exitcode
 
-      cmd = tf_prepare_command(['plan', *args], need_auth: true)
+      cmd = tf_prepare_command(["plan", *args], need_auth: true)
       stream_or_run_terraform(cmd, &block)
     end
 
     def tf_show(file, json: false)
       if json
-        args = ['show', '-json', file]
+        args = ["show", "-json", file]
         cmd = tf_prepare_command(args, need_auth: true)
         capture_terraform(cmd, json: true)
       else
-        args = ['show', file]
+        args = ["show", file]
         cmd = tf_prepare_command(args, need_auth: true)
         run_terraform(cmd)
       end
@@ -63,11 +63,11 @@ module MuxTf
     private
 
     def tf_prepare_command(args, need_auth:)
-      if ENV['MUX_TF_AUTH_WRAPPER'] && need_auth
-        words = Shellwords.shellsplit(ENV['MUX_TF_AUTH_WRAPPER'])
-        [*words, 'terraform', *args]
+      if ENV["MUX_TF_AUTH_WRAPPER"] && need_auth
+        words = Shellwords.shellsplit(ENV["MUX_TF_AUTH_WRAPPER"])
+        [*words, "terraform", *args]
       else
-        ['terraform', *args]
+        ["terraform", *args]
       end
     end
 
@@ -83,18 +83,18 @@ module MuxTf
     def run_terraform(args, **_options)
       status = run_shell(args, return_status: true, echo_command: true, quiet: false)
       OpenStruct.new({
-                       status: status,
-                       success?: status == 0
-                     })
+        status: status,
+        success?: status == 0
+      })
     end
 
     def stream_terraform(args, &block)
       status = run_with_each_line(args, &block)
       # status is a Process::Status
       OpenStruct.new({
-                       status: status.exitstatus,
-                       success?: status.exitstatus == 0
-                     })
+        status: status.exitstatus,
+        success?: status.exitstatus == 0
+      })
     end
 
     # error: true, echo_command: true, indent: 0, raise_on_error: false, detailed_result: false
@@ -102,11 +102,11 @@ module MuxTf
       result = capture_shell(args, error: true, echo_command: false, raise_on_error: false, detailed_result: true)
       parsed_output = JSON.parse(result.output) if json
       OpenStruct.new({
-                       status: result.status,
-                       success?: result.status == 0,
-                       output: result.output,
-                       parsed_output: parsed_output
-                     })
+        status: result.status,
+        success?: result.status == 0,
+        output: result.output,
+        parsed_output: parsed_output
+      })
     rescue JSON::ParserError => e
       fail_with "Execution Failed! - #{result.inspect}"
     end

data/lib/mux_tf/tmux.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'shellwords'
+require "shellwords"
 
 module MuxTf
   module Tmux
@@ -14,13 +14,20 @@ module MuxTf
       end
 
       def find_pane(name)
-        panes = `tmux list-panes -F "\#{pane_id},\#{pane_title}"`.strip.split("\n").map do |row|
-          x = row.split(',')
-          return { id: x[0], name: x[1] }
-        end
+        panes = `tmux list-panes -F "\#{pane_id},\#{pane_title}"`.strip.split("\n").map { |row|
+          x = row.split(",")
+          return {id: x[0], name: x[1]}
+        }
         panes.find { |pane| pane[:name] == name }
       end
 
+      def list_windows
+        `tmux list-windows -F "\#{window_id},\#{window_index},\#{window_name}"`.strip.split("\n").map do |row|
+          x = row.split(",")
+          {id: x[0], index: x[1], name: x[2]}
+        end
+      end
+
       def new_session(name)
         tmux %(new-session -s #{name.inspect} -d)
       end
@@ -38,11 +45,11 @@ module MuxTf
       end
 
       def tile!
-        tmux 'select-layout tiled'
+        tmux "select-layout tiled"
       end
 
       def attach(name, cc: false)
-        tmux %(#{cc && '-CC' || ''} attach -t #{name.inspect}), raise_on_error: false
+        tmux %(#{cc && "-CC" || ""} attach -t #{name.inspect}), raise_on_error: false
       end
 
       def kill_pane(pane_id)
@@ -57,21 +64,21 @@ module MuxTf
       def split_window(mode, target_pane, cwd: nil, cmd: nil)
         case mode
         when :horizontal
-          mode_part = '-h'
+          mode_part = "-h"
         when :vertical
-          mode_part = '-v'
+          mode_part = "-v"
         else
           raise ArgumentError, "invalid mode: #{mode.inspect}"
         end
 
         parts = [
-          'split-window',
+          "split-window",
           cwd && "-c #{cwd}",
           mode_part,
           "-t #{target_pane.inspect}",
           cmd&.inspect
         ].compact
-        tmux parts.join(' ')
+        tmux parts.join(" ")
       end
 
       private