mux_tf 0.14.2 → 0.16.0

data/lib/mux_tf/cli/mux.rb

@@ -24,13 +24,174 @@ module MuxTf
           end
         end
 
-        def run(_args)
+        def run(args)
+          if ENV["MUX_V2"]
+            run_v2(args)
+          else
+            run_v1(args)
+          end
+        end
+
+        def run_create_session
+          project = File.basename(Dir.getwd)
+
+          if Tmux.session_running?(project)
+            log "Killing existing session ..."
+            Tmux.kill_session(project)
+          end
+
+          log "Starting new session ..."
+          with_clean_env do
+            Tmux.new_session project
+          end
+          Tmux.select_pane "initial"
+
+          window_id = Tmux.list_windows.first[:id]
+
+          Tmux.set "remain-on-exit", "on"
+
+          Tmux.set_hook "pane-exited", "select-layout tiled"
+          Tmux.set_hook "window-pane-changed", "select-layout tiled"
+          Tmux.set_hook "pane-exited", "select-layout tiled"
+
+          Tmux.set "mouse", "on"
+
+          puts "\e]0;tmux: #{project}\007"
+
+          Tmux.split_window :horizontal, "#{project}:#{window_id}", cwd: Dir.getwd,
+                                                                    cmd: File.expand_path(File.join(__dir__, "..", "..", "..", "exe", "tf_mux spawner"))
+          Tmux.select_pane "spawner"
+
+          initial_pane = Tmux.find_pane("initial")
+          Tmux.kill_pane initial_pane[:id]
+          Tmux.tile!
+
+          log "Attaching ..."
+          Tmux.attach(project)
+          log "Done!"
+        end
+
+        def parse_control_line(line)
+          keyword, remainder = line.split(" ", 2)
+          case keyword
+          when "%begin"
+            # n1, n2, n3, remainder = remainder.split(" ", 4)
+            p [:begin, n1, n2, n3, remainder]
+          when "%end"
+            # n1, n2, n3, remainder = remainder.split(" ", 4)
+            p [:end, n1, n2, n3, remainder]
+          when "%session-changed"
+            # n1, s1, remainder = remainder.split(" ", 3)
+            # p [:session_changed, n1, s1, remainder]
+          when "%window-pane-changed"
+            # n1, n2, remainder = remainder.split(" ", 3)
+            # p [:window_pane_changed, n1, n2, remainder]
+          when "%layout-change"
+            # ignore
+            # p [:layout_change, remainder]
+          when "%pane-mode-changed"
+            # ignore
+            p [:layout_change, remainder]
+          when "%subscription-changed"
+            sub_name, n1, n2, n3, n4, _, remainder = remainder.split(" ", 7)
+            if sub_name == "pane-info"
+              pane_id, pane_index, pane_title, pane_dead_status = remainder.strip.split(",", 4)
+              if pane_dead_status != ""
+                p [:pane_exited, pane_id, pane_index, pane_title, pane_dead_status]
+                Tmux.kill_pane(pane_id)
+                panes = Tmux.list_panes
+                if panes.length == 1 && panes.first[:name] == "spawner"
+                  Tmux.kill_pane(panes.first[:id])
+                  # its the last pane, so the whole thing should exit
+                end
+              end
+            else
+              p [:subscription_changed, sub_name, n1, n2, n3, n4, remainder]
+            end
+          when "%output"
+            pane, = remainder.split(" ", 2)
+            if pane == "%1"
+              # skip own output
+              # else
+              #   p [:output, pane, remainder]
+            end
+          else
+            p [keyword, remainder]
+          end
+        end
+
+        def run_spawner
+          project = File.basename(Dir.getwd)
+
+          control_thread = Thread.new do
+            puts "Control Thread Started"
+            Tmux.attach_control(project, on_spawn: lambda { |stdin|
+              stdin.write("refresh-client -B \"pane-info:%*:\#{pane_id},\#{pane_index},\#{pane_title},\#{pane_dead_status}\"\n")
+              stdin.flush
+            }, on_line: lambda { |stream, line|
+              if stream == :stdout
+                parse_control_line(line)
+                # p info
+              else
+                p [stream, line]
+              end
+            })
+            puts "Control Thread Exited"
+          end
+
+          begin
+            log "Enumerating folders ..."
+            dirs = enumerate_terraform_dirs
+
+            fail_with "Error: - no subfolders detected! Aborting." if dirs.empty?
+
+            tasks = dirs.map { |dir|
+              {
+                name: dir,
+                cwd: dir,
+                cmd: File.expand_path(File.join(__dir__, "..", "..", "..", "exe", "tf_current"))
+              }
+            }
+
+            if ENV["MUX_TF_AUTH_WRAPPER"]
+              log "Warming up AWS connection ..."
+              words = Shellwords.shellsplit(ENV["MUX_TF_AUTH_WRAPPER"])
+              result = capture_shell([*words, "aws", "sts", "get-caller-identity"], raise_on_error: true)
+              p JSON.parse(result)
+            end
+
+            window_id = Tmux.list_windows.first[:id]
+
+            return if tasks.empty?
+
+            tasks.each do |task|
+              log "launching task: #{task[:name]} ...", depth: 2
+              Tmux.split_window :horizontal, "#{project}:#{window_id}", cmd: task[:cmd], cwd: task[:cwd]
+              Tmux.select_pane task[:name]
+              Tmux.tile!
+              task[:commands]&.each do |cmd|
+                Tmux.send_keys cmd, enter: true
+              end
+            end
+          ensure
+            control_thread.join
+          end
+        end
+
+        def run_v2(args)
           Dotenv.load(".env.mux")
 
-          log "Enumerating folders ..."
-          dirs = enumerate_terraform_dirs
+          if args[0] == "spawner"
+            run_spawner
+          else
+            run_create_session
+          end
+        end
 
-          fail_with "Error: - no subfolders detected! Aborting." if dirs.empty?
+        def run_v1(_args)
+          Dotenv.load(".env.mux")
+
+          dirs = enumerate_terraform_dirs
 
           tasks = dirs.map { |dir|
             {
@@ -104,7 +265,9 @@ module MuxTf
           ignored += ENV["MUX_IGNORE"].split(",") if ENV["MUX_IGNORE"]
 
           dirs = Dir["**/.terraform.lock.hcl"].map { |f| File.dirname(f) }
-          dirs.reject! do |d| d.in?(ignored) end
+          dirs.reject! do |d|
+            d.in?(ignored)
+          end
 
           dirs
         end

data/lib/mux_tf/cli/plan_summary.rb

@@ -6,19 +6,15 @@ module MuxTf
       extend PiotrbCliUtils::Util
       extend PiotrbCliUtils::ShellHelpers
       extend TerraformHelpers
-      import Coloring
+      include Coloring
 
       class << self
         def run(args)
           options = {
-            interactive: false,
             hierarchy: false
           }
 
           args = OptionParser.new { |opts|
-            opts.on("-i") do |v|
-              options[:interactive] = v
-            end
             opts.on("-h") do |v|
               options[:hierarchy] = v
             end
@@ -32,25 +28,20 @@ module MuxTf
                    PlanSummaryHandler.from_data(JSON.parse($stdin.read))
                  end
 
-          if options[:interactive]
-            abort_message = catch(:abort) { plan.run_interactive }
-            log pastel.red("Aborted: #{abort_message}") if abort_message
+          if options[:hierarchy]
+            plan.nested_summary.each do |line|
+              puts line
+            end
           else
-            if options[:hierarchy]
-              plan.nested_summary.each do |line|
-                puts line
-              end
-            else
-              plan.flat_summary.each do |line|
-                puts line
-              end
-              plan.output_summary.each do |line|
-                puts line
-              end
+            plan.flat_summary.each do |line|
+              puts line
+            end
+            plan.output_summary.each do |line|
+              puts line
             end
-            puts
-            puts plan.summary
           end
+          puts
+          puts plan.summary
         end
       end
     end

data/lib/mux_tf/error_handling_methods.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module ErrorHandlingMethods
+    def setup_error_handling(parser, from_states:)
+      parser.state(:init_error, /^Terraform encountered problems during initialisation/, [:none])
+      parser.state(:error_block, /^╷/, from_states | [:after_error, :init_error])
+      parser.state(:error_block_error, /^│ Error: /, [:error_block, :init_error])
+      parser.state(:error_block_warning, /^│ Warning: /, [:error_block, :init_error])
+      parser.state(:after_error, /^╵/, [:error_block, :error_block_error, :error_block_warning, :init_error])
+    end
+
+    def handle_error_states(meta, state, line)
+      case state
+      when :error_block
+        if meta[:init_error]
+          # turn this into an error first
+          meta[:errors] ||= []
+          meta[:errors] << {
+            type: :error,
+            message: meta[:init_error].join("\n")
+            # body: meta[:init_error]
+          }
+          meta.delete(:init_error)
+        end
+        meta[:current_error] = {
+          type: :unknown,
+          body: []
+        }
+      when :error_block_error, :error_block_warning
+        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 :after_error
+        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)
+        end
+      when :init_error
+        meta[:init_error] ||= []
+        meta[:init_error] << line
+      else
+        return false
+      end
+      true
+    end
+
+    def log_unhandled_line(state, line, reason: nil)
+      p [state, pastel.strip(line), reason]
+    end
+
+    def print_errors(meta)
+      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
+    end
+  end
+end

data/lib/mux_tf/handlers/plan_handler.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Handlers
+    class PlanHandler
+    end
+  end
+end

data/lib/mux_tf/handlers.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Handlers
+  end
+end