ecl 1.0.0

data/lib/eclair/grid.rb

@@ -0,0 +1,355 @@
+module Eclair
+  module Grid
+    include CommonHelper
+    extend self
+
+    HEADER_ROWS = 4
+    SORT_FUNCTIONS = {
+      "Name" => lambda {|i| [i.name.downcase, -i.launch_time.to_i]}, 
+    }
+
+    def maxy
+      stdscr.maxy - HEADER_ROWS
+    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 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)
+      end
+    end
+
+    def cell_width
+      stdscr.maxx/column_count
+    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
+      end
+    end
+
+    def render_all
+      clear
+      columns.each do |cols|
+        cols.each do |c|
+          c.render
+        end
+      end
+      render_header
+      refresh
+    end
+
+    def ssh
+      targets = selected.select{|i| i.is_a?(Instance) && i.connectable?}
+      return if targets.empty?
+      close_screen
+
+      cmd = ""
+      if targets.count == 1
+        target = targets.first
+        cmd = target.ssh_cmd
+      else
+        cmds = []
+        session_name = nil
+        session_cmd = nil
+
+        targets.each_with_index do |target, i|
+          if i==0
+            if ENV['TMUX']
+              cmds << "tmux new-window -- '#{target.ssh_cmd}'"
+            else
+              session_name = "eclair#{Time.now.to_i}"
+              session_cmd = "-t #{session_name}"
+              cmds << "tmux new-session -d -s #{session_name} -- '#{target.ssh_cmd}'"
+            end
+          else
+            cmds << "tmux split-window #{session_cmd} -- '#{target.ssh_cmd}'"
+            cmds << "tmux select-layout #{session_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(" && ")
+      end
+      system cmd
+      exit
+    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)
+    end
+
+    def selected
+      @selected ||= []
+    end
+
+    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
+      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]
+
+      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
+      end
+
+      move_cursor(x: newx, y: newy)
+    end
+
+    def cursor
+      @x ||= -1
+      @y ||= -1
+      if @x >=0 && @y >= 0
+        columns[@x][@y]
+      else
+        nil
+      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
+    end
+
+    def start_search
+      @rollback_cursor = [@x, @y]
+      @rollback_mode = @mode
+      @search_str = ""
+    end
+
+    def end_search
+      if cursor
+        move_cursor(mode: @rollback_mode)
+        @mode = @rollback_mode
+      else
+        cancel_search
+      end
+    end
+
+    def cancel_search
+      x,y = @rollback_cursor
+      move_cursor(x: x, y: y, mode: @rollback_mode)
+    end
+
+
+    def move_cursor **options, &block
+      if cursor
+        cursor.toggle_select if mode == :navi
+        cursor.decurrent
+      end
+
+      new_mode = options.delete(:mode)
+      if new_mode && mode != new_mode
+        case new_mode
+        when :search
+          start_search
+        end
+        @mode = new_mode
+      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
+      end
+    end
+
+    def search key
+      @search_str ||= ""
+  
+      move_cursor(mode: :search) do 
+        if key
+          @search_str = @search_str+key
+        else
+          @search_str.chop!
+        end
+
+        goto = query
+
+        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
+        end
+
+        result || [-1,-1]
+      end
+      
+      render_header 
+    end
+
+    def resize
+      columns.each{|col| col.scroll = 0}
+      render_all
+      cursor.check_scroll
+    end
+
+    def cursor_inspect
+      close_screen
+      LessViewer.show cursor.info
+      render_all
+    end
+
+    def debug
+      trap("INT") { raise Interrupt }
+      close_screen
+      binding.pry      
+      render_all
+      trap("INT") { exit }
+    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]
+    end
+
+    def sorted_by
+      SORT_FUNCTIONS.keys[@sort_function_idx]
+    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)
+        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
+    end
+  end
+end

data/lib/eclair/group.rb

@@ -0,0 +1,55 @@
+ module Eclair
+  class Group < Cell
+    array_accessor :items
+
+    def initialize group_name, column = nil
+      super
+      @group_name = group_name
+      @items = []
+      @column = column
+    end
+
+    def << instance
+      @items << instance
+    end
+
+    def x
+      column.x
+    end
+
+    def y
+      column.index(self)
+    end
+
+    def color
+      super(*config.group_color)
+    end
+
+    def format
+      " #{@group_name} (#{count(&:connectable?)}) #{select_indicator}"
+    end
+
+    def header
+      ["Group #{@group_name}",
+      "#{count} Instances Total",
+      "#{count(&:running?)} Instances Running"]
+    end
+
+    def items
+      @items
+    end
+
+    def name
+      @group_name
+    end
+
+    def object
+      @group_name
+    end
+
+    def info
+      @items.map(&:info)
+    end
+  end
+end
+

data/lib/eclair/helpers/aws_helper.rb

@@ -0,0 +1,157 @@
+module Eclair
+  module Aws
+    extend self
+
+    def ec2
+      @ec2 ||= ::Aws::EC2::Client.new
+    end
+
+    def route53
+      @route53 ||= ::Aws::Route53::Client.new
+    end
+
+    def instances
+      fetch_all unless @instances
+      @instances
+    end
+
+    def instance_map
+      @instance_map
+    end
+
+    def images **options
+      if options.delete :force
+        @images_thread.join
+      end
+      @images || []
+    end
+
+    def images?
+      !@images_thread.alive?
+    end
+
+    def dns_records **options
+      if options.delete :force
+        @route53_thread.join
+      end
+      @dns_records || []
+    end
+
+    def dns_records?
+      !@route53_thread.alive?
+    end
+
+    def security_groups **options
+      if options.delete :force
+        @security_groups_thread.join
+      end
+      @security_groups || []
+    end
+
+    def security_groups?
+      !@security_groups_thread.alive?
+    end
+
+    def reload_instances
+      return if @reload_thread && @reload_thread.alive?
+
+      if @reload_thread
+        @instances = @r_instances
+        @instance_map = @r_instances_map
+        @images += @new_images
+        @dns_records = @r_dns_records
+        @security_groups = @r_security_groups
+        Grid.assign
+        @reload_thread = nil
+      end
+
+      return if @last_reloaded && Time.now - @last_reloaded < 5
+
+      @reload_thread = Thread.new do 
+        r_instances, r_instances_map = fetch_instances
+        @new_instances = r_instances.map(&:instance_id) - @instances.map(&:instance_id)
+        if new_instances.empty?
+          @new_images = []
+        else
+          image_ids = @new_instances.map(&:image_id)
+          [
+            Thread.new do
+              @new_images = fetch_images(image_ids)
+            end,
+
+            Thread.new do
+              @r_security_groups = fetch_security_groups
+            end
+          ].each(&:join)
+        end
+        @last_reloaded = Time.now
+      end
+    end
+
+    private
+
+    def fetch_images image_ids
+      ec2.describe_images(image_ids: image_ids).images.flatten
+    end
+
+    def fetch_dns_records
+      hosted_zone_ids = route53.list_hosted_zones.hosted_zones.map(&:id)
+      hosted_zone_ids.map { |hosted_zone_id|
+        route53.list_resource_record_sets(hosted_zone_id: hosted_zone_id).map { |resp|
+          resp.resource_record_sets
+        }
+      }.flatten
+    end
+
+    def fetch_security_groups
+      ec2.describe_security_groups.map{ |resp|
+        resp.security_groups
+      }.flatten
+    end
+
+    def fetch_instances
+      instance_map = {}
+
+      instances = ec2.describe_instances.map{ |resp| 
+        resp.data.reservations.map(&:instances)
+      }.flatten
+
+      instances.each do |i|
+        instance_map[i.instance_id] = i
+      end
+
+      [instances, instance_map]
+    end
+
+    
+    def fetch_all
+      @instances, @instance_map = fetch_instances
+
+      image_ids = @instances.map(&:image_id)
+
+      if @threads
+        @threads.each{ |t| t.kill }
+      end
+
+      Thread.abort_on_exception = true
+      
+      @threads = []
+
+      @threads << @images_thread = Thread.new do
+        @images = fetch_images(image_ids)
+      end
+
+      @threads << @route53_thread = Thread.new do
+        @dns_records = fetch_dns_records
+      end
+
+      @threads << @security_groups_thread = Thread.new do
+        @security_groups = fetch_security_groups
+      end
+    end
+    
+    def find_username image_id
+      config.ssh_username.call(image_id, @images[image_id].name)
+    end
+  end
+end