ecl 1.2.1 → 3.0.0.pre.alpha1

data/lib/eclair/config.rb

@@ -1,9 +1,20 @@
+# frozen_string_literal: true
+require 'curses'
+
 module Eclair
+  module ConfigHelper
+    def config
+      Eclair.config
+    end
+  end
+
   class Config
-    RCFILE = ENV["ECLRC"] || "#{ENV['HOME']}/.eclrc"
-    include Curses
+    KEYS_DIR = "#{ENV['HOME']}/.ecl/keys"
+    CACHE_DIR = "#{ENV['HOME']}/.ecl/.cache"
 
     def initialize
+      @done = false
+      @config_file = ENV["ECLRC"] || "#{ENV['HOME']}/.ecl/config.rb"
       @aws_region = nil
       @columns = 4
       @group_by = lambda do |instance|
@@ -21,17 +32,14 @@ module Eclair
           "ec2-user"
         end
       end
+      @ssh_command          = "ssh"
       @ssh_keys             = {}
-      @ssh_hostname         = :public_ip_address
       @ssh_ports            = [22].freeze
       @ssh_options          = "-o ConnectTimeout=1 -o StrictHostKeyChecking=no".freeze
-      @instance_color       = [COLOR_WHITE, -1].freeze
-      @group_color          = [COLOR_WHITE, -1, A_BOLD].freeze
-      @current_color        = [COLOR_BLACK, COLOR_CYAN].freeze
-      @selected_color       = [COLOR_YELLOW, -1, A_BOLD].freeze
-      @disabled_color       = [COLOR_BLACK, -1, A_BOLD].freeze
-      @search_color         = [COLOR_BLACK, COLOR_YELLOW].freeze
-      @help_color           = [COLOR_BLACK, COLOR_WHITE].freeze
+      @dir_keys             = {}
+      @exec_format          = "{ssh_command} {ssh_options} -p{port} {ssh_key} {username}@{host}"
+      @provider             = :ec2
+      @get_pods_option      = ""
 
       instance_variables.each do |var|
         Config.class_eval do
@@ -39,23 +47,55 @@ module Eclair
         end
       end
 
-      unless File.exists? RCFILE
+      # Migrate old ~/.eclrc to ~/.ecl/config.rb
+      old_conf  = "#{ENV['HOME']}/.eclrc"
+      new_dir = "#{ENV['HOME']}/.ecl"
+      new_conf  = "#{ENV['HOME']}/.ecl/config.rb"
+
+      if !File.exists?(new_conf) && File.exists?(old_conf)
+        FileUtils.mkdir_p new_dir
+        FileUtils.mv old_conf, new_conf
+        puts "#{old_conf} migrated to #{new_conf}"
+        puts "Please re-run eclair"
+        exit
+      end
+
+      unless File.exists? @config_file
         template_path = File.join(File.dirname(__FILE__), "..", "..", "templates", "eclrc.template")
-        FileUtils.cp(template_path, RCFILE)
-        puts "#{RCFILE} successfully created. Edit it and run again!"
+        FileUtils.mkdir_p(File.dirname(@config_file))
+        FileUtils.cp(template_path, @config_file)
+        puts "#{@config_file} successfully created. Edit it and run again!"
         exit
       end
+
+      key_path = "#{new_dir}/keys"
+      FileUtils.mkdir_p key_path unless Dir.exists? key_path
+      # FileUtils.mkdir_p CACHE_DIR unless Dir.exists? CACHE_DIR
+    end
+
+    def after_load
+      dir_keys = {}
+
+      Dir["#{KEYS_DIR}/*"].each do |key|
+        if File.file? key
+          dir_keys[File.basename(key, ".*")] = key
+        end
+      end
+      @ssh_keys.merge!(dir_keys)
     end
   end
 
   extend self
-  
-  def config
-    unless @config
-      @config = Config.new
-      load Config::RCFILE
-    end
 
+  def init_config
+    @config = Config.new
+    load @config.config_file
+    raise unless @done
+    @config.after_load
+  end
+
+
+  def config
     if @config.aws_region
       ::Aws.config.update(region: @config.aws_region)
     end
@@ -63,7 +103,14 @@ module Eclair
     @config
   end
 
-  def configure
-    yield config
+  def profile
+    ENV["ECL_PROFILE"] || "default"
+  end
+
+  def configure name = "default"
+    if profile == name
+      @done = true
+      yield config
+    end
   end
 end

data/lib/eclair/grid.rb

@@ -1,355 +1,323 @@
+# frozen_string_literal: true
+require "eclair/group_item"
+require "eclair/color"
+
 module Eclair
-  module Grid
-    include CommonHelper
-    extend self
+  class Grid
+    attr_reader :mode
+
+    def initialize keyword = ""
+      case config.provider
+      when :ec2
+        require "eclair/providers/ec2"
+        @provider = EC2Provider
+      when :k8s
+        require "eclair/providers/k8s"
+        @provider = K8sProvider
+      when :gce
+        require "eclair/providers/gce"
+        @provider = GCEProvider
+      end
+      @item_class = @provider.item_class
 
-    HEADER_ROWS = 4
-    SORT_FUNCTIONS = {
-      "Name" => lambda {|i| [i.name.downcase, -i.launch_time.to_i]}, 
-    }
+      @scroll = config.columns.times.map{0}
+      @header_rows = 4
+      @cursor = [0,0]
+      @cell_width = Curses.stdscr.maxx/config.columns
+      @maxy = Curses.stdscr.maxy - @header_rows
+      @mode = :assign
+      @search_buffer = ""
 
-    def maxy
-      stdscr.maxy - HEADER_ROWS
+      @provider.prepare keyword
+      assign
+      at(*@cursor).select(true)
+      draw_all
+      transit_mode(:nav)
     end
-    
-    def render_header
-      if mode == :search
-        if cursor
-          header = ["Searching #{@search_str}", "Found #{cursor.name}", ""]
-        else
-          header = ["Searching #{@search_str}", "None Found", ""]
-        end
-      else
-        header = cursor.header
-      end
 
-      header.each_with_index do |line,i|
-        setpos(i,0)
-        clrtoeol
-        addstr(line)
-      end
-      render_help
-    end
+    def move key
+      return unless at(*@cursor)
+      x,y = @cursor
+      mx,my = {
+        Curses::KEY_UP => [0,-1],
+        ?k => [0,-1],
+        Curses::KEY_DOWN => [0,1],
+        ?j => [0,1],
+        Curses::KEY_LEFT => [-1,0],
+        ?h => [-1,0],
+        Curses::KEY_RIGHT => [1,0],
+        ?l => [1,0],
+      }[key]
 
-    def render_help
-      setpos(3,0)
-      clrtoeol
-
-      helps = {
-        "Enter" => "SSH",
-        "Space" => "Select",
-        "[a-z0-9]" =>  "Search",
-        "?" => "Inspect",
-        "!" => "Open Ruby REPL",
-      }
-
-      attron(Color.fetch(*config.help_color)) do
-        addstr helps.map{ |key, action|   
-          " #{key} => #{action}"
-        }.join("    ").slice(0,stdscr.maxx).ljust(stdscr.maxx)
+      newx = x
+      loop do
+        newx = (newx + mx) % @grid.length
+        break if @grid[newx].length > 0
+      end
+      newy = (y + my - @scroll[x] + @scroll[newx])
+      if my != 0
+        newy %= @grid[newx].length
+      end
+      if newy >= @grid[newx].length
+        newy = @grid[newx].length-1
       end
-    end
 
-    def cell_width
-      stdscr.maxx/column_count
+      move_cursor(newx, newy)
     end
 
-    def start
-      assign
-      move_cursor(x: 0, y: 0)
-      render_all
-    end
-
-    def assign
-      sort_function = lambda {|i| [i.name.downcase, -i.launch_time.to_i]}
-      @group_map ||= {}
-      if config.group_by
-        Aws.instances.group_by(&config.group_by).each do |group, instances|
-          if @group_map[group]
-            group_cell  = @group_map[group]
-          else
-            col = columns[target_col]
-            group_cell = Group.new(group, col)
-            col << group_cell
-            @group_map[group] = group_cell
-          end
-          instances.each do |i|
-            unless group_cell.find{|j| j.instance_id == i.instance_id}
-              obj = Instance.new(i.instance_id, col)
-              group_cell << obj
-            end
-          end
-          group_cell.items.sort_by!(&sort_function)
-        end
-      else
-        col_limit = (Aws.instances.count - 1) / config.columns + 1
-        iter = Aws.instances.map{|i| Instance.new(i.instance_id)}.sort_by(&sort_function).each
-        columns.each do |col|
-          col_limit.times do 
-            begin
-              i = iter.next
-              i.column = col
-              col << i
-            rescue StopIteration
-              break
-            end
-          end
-        end
+    def space
+      if @mode == :nav
+        transit_mode(:sel)
       end
-    end
 
-    def render_all
-      clear
-      columns.each do |cols|
-        cols.each do |c|
-          c.render
-        end
+      at(*@cursor)&.toggle_select
+
+      if @mode == :sel && @provider.items.all?{|i| !i.selected}
+        transit_mode(:nav)
       end
-      render_header
-      refresh
+
+
+      draw(*@cursor)
     end
 
-    def ssh
-      targets = selected.select{|i| i.is_a?(Instance) && i.connectable?}
+    def action
+      targets = @provider.items.select{|i| i.selected && i.connectable?}
+
       return if targets.empty?
-      close_screen
+      Curses.close_screen
 
-      cmd = ""
-      if targets.count == 1
-        target = targets.first
-        cmd = target.ssh_cmd
+      if targets.length == 1
+        cmd = targets.first.command
       else
         cmds = []
-        session_name = nil
-        session_cmd = nil
+        target_cmd = ""
 
         targets.each_with_index do |target, i|
-          if i==0
-            if ENV['TMUX']
-              cmds << "tmux new-window -- '#{target.ssh_cmd}'"
-            else
+          if i == 0
+            if ENV['TMUX'] # Eclair called inside of tmux
+              # Create new session and save window id
+              window_name = `tmux new-window -P -- '#{target.command}'`.strip
+              target_cmd = "-t #{window_name}"
+            else # Eclair called from outside of tmux
+              # Create new session and save session
               session_name = "eclair#{Time.now.to_i}"
-              session_cmd = "-t #{session_name}"
-              cmds << "tmux new-session -d -s #{session_name} -- '#{target.ssh_cmd}'"
+              target_cmd = "-t #{session_name}"
+              `tmux new-session -d -s #{session_name} -- '#{target.command}'`
             end
-          else
-            cmds << "tmux split-window #{session_cmd} -- '#{target.ssh_cmd}'"
-            cmds << "tmux select-layout #{session_cmd} tiled"
+          else # Split layout and
+            cmds << "split-window #{target_cmd} -- '#{target.command}'"
+            cmds << "select-layout #{target_cmd} tiled"
           end
         end
-        cmds << "tmux set-window-option #{session_cmd} synchronize-panes on" 
-        cmds << "tmux attach #{session_cmd}" unless ENV['TMUX']
-        cmd = cmds.join(" && ")
+        cmds << "set-window-option #{target_cmd} synchronize-panes on"
+        cmds << "attach #{target_cmd}" unless ENV['TMUX']
+        cmd = "tmux #{cmds.join(" \\; ")}"
       end
-      system cmd
-      exit
+      system(cmd)
+      exit()
+      resize
     end
 
-    def column_count
-      columns.count{|col| !col.empty?}
-    end
-
-    def columns
-      @columns ||= config.columns.times.map{|idx| Column.new(idx)}.to_a
-    end
-
-    def rows
-      columns.map(&:count).max
-    end
-
-    def target_col
-      counts = columns.map(&:count)
-      counts.index(counts.min)
+    def resize
+      Curses.clear
+      @scroll.fill(0)
+      @cell_width = Curses.stdscr.maxx/config.columns
+      @maxy = Curses.stdscr.maxy - @header_rows
+      rescroll(*@cursor)
+      draw_all
     end
 
-    def selected
-      @selected ||= []
-    end
+    def transit_mode to
+      return if to == @mode
 
-    def mode
-      @mode ||= :navi
-    end
-
-    def select
-      end_search if mode == :search
-      if mode == :navi
-        @mode = :select
-        cursor.toggle_select
-      end
-      cursor.toggle_select
-      if selected.empty?
-        @mode = :navi
-        cursor.toggle_select
+      case @mode
+      when :nav
+        at(*@cursor)&.select(false)
+      when :sel
+      when :search
+      when :assign
       end
-    end
 
-    def move key
-      end_search if mode == :search
-      mx,my = {
-        KEY_UP => [0,-1],
-        "k" => [0,-1],
-        KEY_DOWN => [0,1],
-        "j" => [0,1],
-        KEY_LEFT => [-1,0],
-        "h" => [-1,0],
-        KEY_RIGHT => [1,0],
-        "l" => [1,0],
-      }[key]
+      @mode = to
 
-      newx = (@x + mx) % column_count
-      newy = (@y + my - columns[@x].scroll + columns[newx].scroll)
-      if my != 0
-        newy %= columns[newx].count 
-      end
-      if newy >= columns[newx].count
-        newy = columns[newx].count-1
+      case @mode
+      when :nav
+        at(*@cursor)&.select(true)
+      when :sel
+      when :search
+      when :assign
+        move_cursor(0,0)
       end
 
-      move_cursor(x: newx, y: newy)
+      draw_all
     end
 
-    def cursor
-      @x ||= -1
-      @y ||= -1
-      if @x >=0 && @y >= 0
-        columns[@x][@y]
+    def start_search
+      transit_mode(:search)
+    end
+
+    def end_search
+      if @provider.items.any?{|i| i.selected}
+        transit_mode(:sel)
       else
-        nil
+        transit_mode(:nav)
       end
     end
 
-    def query
-      return nil if @search_str == ""
-      result = columns.map(&:expand).flatten.grep(Instance).map(&:name).max_by{|name| name.score @search_str}
-      return nil if result.score(@search_str) == 0.0
-      result
+    def clear_search
+      @search_buffer = ""
+      update_search
     end
 
-    def start_search
-      @rollback_cursor = [@x, @y]
-      @rollback_mode = @mode
-      @search_str = ""
-    end
+    def append_search key
+      return unless key
 
-    def end_search
-      if cursor
-        move_cursor(mode: @rollback_mode)
-        @mode = @rollback_mode
+      if @search_buffer.length > 0 && key == 127 # backspace
+        @search_buffer = @search_buffer.chop
+      elsif key.to_s.length == 1
+        begin
+          @search_buffer = @search_buffer + key.to_s
+        rescue
+          return
+        end
       else
-        cancel_search
+        return
       end
-    end
 
-    def cancel_search
-      x,y = @rollback_cursor
-      move_cursor(x: x, y: y, mode: @rollback_mode)
+      update_search
     end
 
+    private
 
-    def move_cursor **options, &block
-      if cursor
-        cursor.toggle_select if mode == :navi
-        cursor.decurrent
-      end
+    def move_cursor x, y
+      prev = @cursor.dup
+      @cursor = [x, y]
 
-      new_mode = options.delete(:mode)
-      if new_mode && mode != new_mode
-        case new_mode
-        when :search
-          start_search
-        end
-        @mode = new_mode
+      prev_item = at(*prev)
+      curr_item = at(*@cursor)
+      rescroll(*@cursor)
+      if @mode == :nav
+        prev_item.select(false)
+        curr_item.select(true)
       end
+      draw(*prev) if prev_item
+      draw(*@cursor) if curr_item
+      update_header(curr_item.header) if curr_item
+    end
 
-      if block
-        @x, @y = block.call
-      else
-        @x = options.delete(:x) || @x
-        @y = options.delete(:y) || @y
-      end
 
-      if cursor
-        cursor.toggle_select if mode == :navi
-        cursor.current
+    def update_header str, pos = 0
+      Curses.setpos(0, 0)
+      Curses.clrtoeol
+      Curses.addstr(@mode.to_s)
+      str.split("\n").map(&:strip).each_with_index do |line, i|
+        Curses.setpos(i + pos + 1, 0)
+        Curses.clrtoeol
+        Curses.addstr(line)
       end
     end
 
-    def search key
-      @search_str ||= ""
-  
-      move_cursor(mode: :search) do 
-        if key
-          @search_str = @search_str+key
-        else
-          @search_str.chop!
-        end
+    def update_search
+      assign
+      Curses.clear
+      draw_all
 
-        goto = query
+      Curses.setpos(@header_rows - 1, 0)
+      Curses.clrtoeol
+      if @mode != :search && @search_buffer.empty?
+        update_header('/: Start search')
+      else
+        update_header("/#{@search_buffer}")
+      end
+    end
 
-        result = nil
-        columns.each do |col|
-          target = col.find {|item| item.is_a?(Instance) && item.name == goto}
-          if target
-            result = [target.x, target.y]
-            break
-          end
+    def rescroll x, y
+      unless (@scroll[x]...@maxy+@scroll[x]).include? y
+        if y < @scroll[x]
+          @scroll[x] = y
+        elsif y >= @maxy
+          @scroll[x] = y - @maxy + 1
+        end
+        (@scroll[x]...@maxy+@scroll[x]).each do |ty|
+          draw_item(x, ty)
         end
-
-        result || [-1,-1]
       end
-      
-      render_header 
     end
 
-    def resize
-      columns.each{|col| col.scroll = 0}
-      render_all
-      cursor.check_scroll
+    def at x, y
+      @grid[x][y]
     end
 
-    def cursor_inspect
-      close_screen
-      LessViewer.show cursor.info
-      render_all
+    def make_label target
+      ind = (@mode != :nav && target.selected) ? "*" : " "
+      label = "#{target.label} #{ind}"
+      label.slice(0, @cell_width).ljust(@cell_width)
     end
 
-    def debug
-      trap("INT") { raise Interrupt }
-      close_screen
-      binding.pry      
-      render_all
-      trap("INT") { exit }
+    def draw_all
+      @grid.each_with_index do |column, x|
+        column.each_with_index do |_, y|
+          draw_item(x,y)
+        end
+      end
+      case @mode
+      when :nav, :sel
+        update_header(at(*@cursor)&.header || "No Match")
+      end
     end
 
-    def next_sort_function
-      @sort_function_idx ||= -1
-      @sort_function_idx = (@sort_function_idx + 1) % SORT_FUNCTIONS.count
-      SORT_FUNCTIONS.values[@sort_function_idx]
+    def color x, y
+      if @cursor == [x,y]
+        Color.fetch(Curses::COLOR_BLACK, Curses::COLOR_CYAN)
+      else
+        Color.fetch(*@grid[x][y].color)
+      end
     end
 
-    def sorted_by
-      SORT_FUNCTIONS.keys[@sort_function_idx]
+    def draw_item x, y
+      target = @grid[x].select{|item| item.visible}[y]
+
+      drawy = y - @scroll[x]
+      if drawy < 0 || drawy + @header_rows >= Curses.stdscr.maxy
+        return
+      end
+      cell_color = color(x,y)
+      Curses.setpos(drawy + @header_rows, x * @cell_width)
+      Curses.attron(cell_color) do
+        Curses.addstr make_label(target)
+      end
+      Curses.refresh
     end
 
-    def change_sort
-      stored_cursor = cursor
-      sort_function = next_sort_function
-      columns.each do |column| 
-        column.groups.each do |group|
-          group.items.sort_by!(&sort_function)
+    def draw x, y
+      target = @grid[x][y]
+      draw_item(x, y)
+      if target.is_a?(GroupItem)
+        (y+1).upto(y+target.length).each do |ny|
+          draw_item(x, ny)
         end
       end
-      @x, @y = stored_cursor.x, stored_cursor.y
-      render_all
     end
 
-    def reload
-      clear
-      addstr("reloading")
-      refresh
-      Aws.reload_instances
-      assign
-      render_all
+    def assign
+      old_mode = @mode
+      transit_mode(:assign)
+      @grid = config.columns.times.map{[]}
+      visible_items = @provider.filter_items(@search_buffer)
+      @groups = visible_items.group_by(&config.group_by)
+      @groups.each do |name, items|
+        group_name = "#{name} (#{items.length})"
+        target = @grid.min_by(&:length)
+        target << @provider.group_class.new(group_name, items)
+        items.sort_by(&:label).each do |item|
+          target << item
+        end
+      end
+      transit_mode(old_mode)
+    end
+
+    def config
+      Eclair.config
     end
   end
 end