db_sucker 3.0.0

data/lib/db_sucker/application/window/dialog.rb

@@ -0,0 +1,142 @@
+module DbSucker
+  class Application
+    class Window
+      class Dialog
+        attr_accessor :border_color
+
+        BOX = {
+          tl: "┌",
+          t: "─",
+          tr: "┐",
+          l: "│",
+          r: "│",
+          bl: "└",
+          b: "─",
+          br: "┘",
+          hrl: "├",
+          hr: "─",
+          hrr: "┤",
+        }
+
+        def initialize window, &block
+          @window = window
+          @width = false
+          @border_color = :yellow
+          @border_padding = 1
+          @separator_padding = 1
+          @lines = []
+          block.call(self)
+        end
+
+        def line str = nil, color = :yellow, &block
+          if block
+            @lines << [].tap{|a| block.call(a) }
+          else
+            @lines << [[str, color]]
+          end
+        end
+
+        def br
+          @lines << []
+        end
+
+        def hr
+          @lines << :hr
+        end
+
+        def button *a
+          @lines.concat(build_button(*a))
+        end
+
+        def build_button str, color = :yellow
+          tl = BOX[:tl]
+          t = BOX[:t]
+          tr = BOX[:tr]
+          l = BOX[:l]
+          r = BOX[:r]
+          bl = BOX[:bl]
+          b = BOX[:b]
+          br = BOX[:br]
+          width = str.length + 2
+          [].tap do |a|
+            a << [["#{tl}" << "".ljust(width, t) << "#{tr}", color]]
+            a << [["#{l}" << " #{str} ".ljust(width, t) << "#{r}", color]]
+            a << [["#{bl}" << "".ljust(width, b) << "#{br}", color]]
+          end
+        end
+
+        def button_group buttons = [], spaces = 2, &block
+          spaces = buttons if block
+          btns = block ? [].tap{|a| block.call(a) } : buttons.dup
+          spaces = "".ljust(spaces, " ")
+          first = btns.shift
+
+          btns.each_with_index do |lines, bi|
+            lines.each_with_index do |l, i|
+              first[i] << [spaces, :yellow]
+              first[i].concat(l)
+            end
+          end
+
+          @lines.concat first
+        end
+
+        # -----------------------------------------------------------
+
+        def _nl
+          @window.next_line
+        end
+
+        def _hr
+          l = BOX[:hrl]
+          r = BOX[:hrr]
+          m = "".ljust(@width - l.length - r.length, BOX[:hr])
+          @separator_padding.times { _line }
+          @window.send(@border_color, "#{l}#{m}#{r}")
+          _nl
+        end
+
+        def _line parts = []
+          return _hr if parts == :hr
+          l = BOX[:l]
+          r = BOX[:r]
+          p = "".ljust(@border_padding, " ")
+
+          @window.send(@border_color, "#{l}#{p}")
+          parts.each do |str, color|
+            @window.send(color, str)
+          end
+          @window.send(@border_color, "".ljust(@width - l.length - r.length - (p.length * 2) - parts.map{|s, _| s.length }.sum, " "))
+          @window.send(@border_color, "#{p}#{r}")
+          _nl
+        end
+
+        def _tborder
+          tl = BOX[:tl]
+          tr = BOX[:tr]
+          m = "".ljust(@width - tl.length - tr.length, BOX[:t])
+          @window.send(@border_color, "#{tl}#{m}#{tr}")
+          _nl
+        end
+
+        def _bborder
+          bl = BOX[:bl]
+          br = BOX[:br]
+          m = "".ljust(@width - bl.length - br.length, BOX[:b])
+          @window.send(@border_color, "#{bl}#{m}#{br}")
+        end
+
+        def render!
+          @width = @lines.map{|c| c.is_a?(Array) ? c.map{|s, _| s.length }.sum : 0 }.compact.max + (@border_padding * 2) + BOX[:l].length + BOX[:r].length
+
+          _tborder
+          @border_padding.times { _line }
+          @lines.each {|parts| _line(parts) }
+          @border_padding.times { _line }
+          _bborder
+        end
+      end
+    end
+  end
+end
+

data/lib/db_sucker/application/window/keypad/core.rb

@@ -0,0 +1,85 @@
+module DbSucker
+  class Application
+    class Window
+      class Keypad
+        module Core
+          def sync &block
+            @monitor.synchronize(&block)
+          end
+
+          def sklaventreiber
+            @window.sklaventreiber
+          end
+
+          def app
+            @window.app
+          end
+
+          def enabled?
+            app.opts[:window_keypad]
+          end
+
+          def start_loop
+            return false unless enabled?
+            @keyloop = app.spawn_thread(:window_keypad_loop) do |thr|
+              loop {
+                begin
+                  handle_input(@window.send(:getch))
+                rescue StandardError => ex
+                  app.notify_exception("DbSucker::Window::Keypad encountered an input handle error on tick ##{@window.tick}", ex)
+                end
+              }
+            end
+          end
+
+          def stop_loop
+            return unless @keyloop
+            sync { @keyloop.kill }
+            @keyloop.join
+          end
+
+          def prompt! *a, &b
+            return false unless enabled?
+            @prompt.set!(*a, &b)
+          end
+
+          def _detect_worker arg, &block
+            sklaventreiber.sync do
+              if arg == "--all"
+                sklaventreiber.workers.each{|w| block.call(w) }
+              else
+                wrk = sklaventreiber.workers.detect do |w|
+                  if arg.start_with?("^")
+                    w.table.match(/#{arg}/i)
+                  elsif arg.start_with?("/")
+                    w.table.match(/#{arg[1..-1]}/i)
+                  else
+                    w.table == arg
+                  end
+                end
+                if wrk
+                  block.call(wrk)
+                else
+                  prompt!("Could not find any worker by the pattern `#{arg}'", color: :red)
+                end
+              end
+            end
+          end
+
+          def _eval evil
+            return if evil.blank?
+            app.dump_file "eval-result", true do |f|
+              begin
+                f.puts("#{evil}\n\n")
+                f.puts(app.sync{ app.instance_eval(evil) })
+              rescue StandardError => ex
+                f.puts("#{ex.class}: #{ex.message}")
+                ex.backtrace.each {|l| f.puts("  #{l}") }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/db_sucker/application/window/keypad.rb

@@ -0,0 +1,174 @@
+module DbSucker
+  class Application
+    class Window
+      class Keypad
+        include Core
+        attr_reader :prompt, :keyloop, :window
+
+        def initialize window
+          @window = window
+          @prompt = Prompt.new(@window, self)
+          @monitor = Monitor.new
+        end
+
+        HELP_INFO = {
+          key_bindings: [
+            ["?", "shows this help"],
+            ["^", "eval prompt (app context, synchronized)"],
+            ["L", "show latest spooled log entries (no scrolling)"],
+            ["P", "kill SSH polling (if it stucks)"],
+            ["T", "create core dump and open in editor"],
+            ["q", "quit prompt"],
+            ["Q", "same as ctrl-c"],
+            [":", "main prompt"],
+          ],
+          main_commands: [
+            [["?", %w[h elp]], [], "shows this help"],
+            [[%w[q uit]], [], "quit prompt"],
+            [["q!", "quit!"], [], "same as ctrl-c"],
+            [["kill"], [], "(dirty) interrupts all workers"],
+            [["kill!"], [], "(dirty) essentially SIGKILL (no cleanup)"],
+            [["dump"], [], "create and open coredump"],
+            [["eval"], [[:optional, "code"]], "executes code or opens eval prompt (app context, synchronized)"],
+            [[%w[c ancel]], [[:mandatory, %w[table_name --all]]], "cancels given or all workers"],
+            [[%w[p ause]], [[:mandatory, %w[table_name --all]]], "pauses given or all workers"],
+            [[%w[r esume]], [[:mandatory, %w[table_name --all]]], "resumes given or all workers"],
+          ],
+        }
+
+        def handle_input ch
+          sync do
+            if @prompt.interactive?
+              @prompt.handle_input(ch)
+            else
+              case ch
+              when ":" then main_prompt
+              when "^" then eval_prompt # (@development)
+              when "L" then show_log # (@development)
+              when "T" then dump_core # (@development)
+              when "P" then kill_ssh_poll
+              when "?" then show_help
+              when "q" then quit_dialog
+              when "Q" then $core_runtime_exiting = 1
+              end
+            end
+          end
+        end
+
+        def main_prompt
+          prompt!(":") do |raw|
+            break if raw.blank?
+            args = raw.split(" ")
+            cmd = args.shift
+            case cmd
+              when "?", "h", "help" then show_help
+              when "c", "cancel" then cancel_workers(args)
+              when "q", "quit" then quit_dialog
+              when "q!", "quit!" then $core_runtime_exiting = 1
+              when "kill" then kill_workers
+              when "kill!" then kill_app
+              when "dump" then dump_core
+              when "eval" then args.any? ? _eval(args.join(" ")) : eval_prompt
+              when "p", "pause" then pause_workers(args)
+              when "r", "resume" then resume_workers(args)
+            end
+          end
+        end
+
+        def eval_prompt
+          prompt!("eval> ") {|evil| _eval(evil) }
+        end
+
+        def quit_dialog
+          q = "Do you want to abort all operations and quit?"
+          p = Proc.new do
+            blue q
+            gray " [y/q/t/1 n/f/0] "
+          end
+          prompt!(q,
+            prompt: p,
+            return_on_buffer: true,
+            capture_enter: false,
+            has_cursor: false
+          ) do |response|
+            if response == "q" || @window.strbool(response) == true
+              $core_runtime_exiting = 1
+            end
+          end
+        end
+
+        def show_help
+          view_was = window.change_view(:help)
+          prompt!("[press any key to return]",
+            return_on_buffer: true,
+            capture_enter: false,
+            has_cursor: false,
+            capture_escape: false,
+            cursor_visible: false
+          ) do |response|
+            window.change_view(view_was)
+          end
+        end
+
+        def show_log
+          view_was = window.change_view(:log)
+          prompt!("[press any key to return]",
+            return_on_buffer: true,
+            capture_enter: false,
+            has_cursor: false,
+            capture_escape: false,
+            cursor_visible: false
+          ) do |response|
+            window.change_view(view_was)
+          end
+        end
+
+        def pause_workers args
+          if args[0].is_a?(String)
+            _detect_worker(args.join(" "), &:pause)
+          else
+            prompt!("Usage: :p(ause) <table_name|--all>", color: :yellow)
+          end
+        end
+
+        def resume_workers args
+          if args[0].is_a?(String)
+            _detect_worker(args.join(" "), &:unpause)
+          else
+            prompt!("Usage: :r(esume) <table_name|--all>", color: :yellow)
+          end
+        end
+
+        def cancel_workers args
+          if args[0].is_a?(String)
+            _detect_worker(args.join(" ")) do |wrk|
+              wrk.cancel! "canceled by user"
+            end
+          else
+            prompt!("Usage: :c(cancel) <table_name|--all>", color: :yellow)
+          end
+        end
+
+        def kill_ssh_poll
+          return if sklaventreiber.workers.select{|w| !w.done? || w.sshing }.any?
+          sklaventreiber.poll.try(:kill)
+        end
+
+        def kill_workers
+          Thread.list.each do |thr|
+            thr.raise(Interrupt) if thr[:managed_worker]
+          end
+        end
+
+        def kill_app
+          exit!
+        end
+
+        def dump_core
+          app.dump_core
+        end
+      end
+    end
+  end
+end
+

data/lib/db_sucker/application/window/prompt.rb

@@ -0,0 +1,124 @@
+module DbSucker
+  class Application
+    class Window
+      class Prompt
+        attr_reader :cpos, :label, :buffer, :opts
+
+        def initialize window, keypad
+          @window = window
+          @keypad = keypad
+          reset_state(true)
+        end
+
+        def active?
+          @active
+        end
+
+        def interactive?
+          active? && @callback
+        end
+
+        def reset_state initializing = false
+          unless initializing
+            @window.set_cursor(0)
+            @keypad.app.fire(:prompt_stop, @label)
+            @window.force_cursor(nil)
+          end
+          @active = false
+          @buffer = ""
+          @label = nil
+          @callback = nil
+          @cpos = 0
+          @opts = {
+            color: :blue,
+            return_on_buffer: false,
+            capture_enter: true,
+            capture_escape: true,
+            has_cursor: true,
+            prompt: nil, # proc
+            cursor_visible: true,
+          }
+        end
+
+        def set! label, opts = {}, &callback
+          @label = label
+          @callback = callback
+          @active = true
+          @opts = @opts.merge(opts)
+          @keypad.app.fire(:prompt_start, @label, @opts)
+          @window.set_cursor(@opts[:cursor_visible] ? 2 : 0)
+        end
+
+        def render target, line
+          _this = self
+          target.instance_eval do
+            return unless _this.active?
+            setpos(line, 0)
+            clrtoeol
+            setpos(line, 0)
+            if _this.opts[:prompt]
+              instance_eval(&_this.opts[:prompt])
+            else
+              send(_this.opts[:color], _this.label)
+            end
+            white(_this.buffer)
+            force_cursor(line, stdscr.curx + _this.cpos)
+          end
+        end
+
+        def handle_input ch
+          case ch
+            when 27 then (@opts[:capture_escape] ? _escape : sbuf(ch))
+            when 127 then (@opts[:has_cursor] ? _backspace : sbuf(ch))
+            when 330 then (@opts[:has_cursor] ? _delete : sbuf(ch))
+            when 260 then (@opts[:has_cursor] ? _left_arrow : sbuf(ch))
+            when 261 then (@opts[:has_cursor] ? _right_arrow : sbuf(ch))
+            when 13 then (@opts[:capture_enter] ? _enter : sbuf(ch))
+            else sbuf(ch)
+          end
+        end
+
+        def sbuf ch
+          #@buffer.concat(ch.bytes.to_s)
+          @cpos.zero? ? @buffer.concat(ch) : @buffer.insert(@cpos - 1, ch)
+          if @opts[:return_on_buffer].is_a?(Regexp)
+            _enter if @buffer.match(@opts[:return_on_buffer])
+          elsif @opts[:return_on_buffer].is_a?(Proc)
+            _enter if @opts[:return_on_buffer].call(@buffer, ch)
+          elsif @opts[:return_on_buffer]
+            _enter
+          end
+        end
+
+        def _escape
+          reset_state
+        end
+
+        def _backspace
+          @buffer.slice!(@cpos - 1)
+        end
+
+        def _delete
+          return if @cpos.zero?
+          @buffer.slice!(@cpos)
+          @cpos += 1
+        end
+
+        def _left_arrow
+          @cpos = [@cpos - 1, -@buffer.length].max
+        end
+
+        def _right_arrow
+          @cpos = [@cpos + 1, 0].min
+        end
+
+        def _enter
+          _b = @buffer
+          _c = @callback
+          reset_state
+          _c.call(_b)
+        end
+      end
+    end
+  end
+end