honcho 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45989ba8f3704c6d5172f9518e7bfc1c2201d6db
-  data.tar.gz: 9e8f3b779d67d975a8ccdb7f30ba30ab933c04da
+  metadata.gz: a323fb5a455f095cb25c7678de5528b064163773
+  data.tar.gz: f1c5281e293b58abb6ffa79ce3a57f8ef7a8f574
 SHA512:
-  metadata.gz: b3ad82f616bc1b8deeeff75a498889f5c7804d20145a58e2dd4b1964dfa4d69bda29efd3773f5d13f92184751736d285abf597bc0095707bbb7fe4927926a62f
-  data.tar.gz: d541b3ad3601e544e244ef2e1ad1a32bf02e9c892dba2b32f7ea7a09695358e8da50a272fbe58d6f6eab77096177b2e81e96b4d868f1acb9b2f259023d889e03
+  metadata.gz: e89facaef2ec526648f8bcc49ce39d71d4b1c91fde373f60f5c081aaafa1f9cf26278828bbd429ffbd61f9ad022347747ac9deaaf0f35916530bbd5e39b7d19a
+  data.tar.gz: fa05afec855e45ee374c328d664651f6481bd4ae6287d8800a9cf1c324afb26a2a6ee17564d81daf33e4767f141344c15146a4bb5c7119ae381621559d553cb5

data/bin/honcho

@@ -13,6 +13,14 @@ OptionParser.new do |opts|
   opts.on('-c', '--config path', 'specify config file path') do |path|
     options[:config] = path
   end
+
+  opts.on('--ui', 'enable top-like user interface') do
+    options[:ui] = true
+  end
 end.parse!
 
-Honcho::Runner.new(options).run
+if options[:ui]
+  Honcho::UIRunner.new(options).run
+else
+  Honcho::Runner.new(options).run
+end

data/lib/honcho/adapters/base.rb

@@ -11,6 +11,10 @@ module Honcho
 
       attr_reader :config, :redis, :runner, :running, :stopping
 
+      def type
+        self.class.name.split(':').last.downcase
+      end
+
       def check_for_work
         if run?
           start
@@ -86,6 +90,10 @@ module Honcho
         @running = false
       end
 
+      def total_count
+        queued_count + busy_count
+      end
+
       private
 
       def log(*args)
@@ -105,11 +113,11 @@ module Honcho
       end
 
       def work_to_do?
-        raise NotImplementedError, "please define #{this.class.name}##{__method__}"
+        queued_count > 0
       end
 
       def work_being_done?
-        raise NotImplementedError, "please define #{this.class.name}##{__method__}"
+        busy_count > 0
       end
     end
   end

data/lib/honcho/adapters/resque.rb

@@ -1,17 +1,15 @@
 module Honcho
   module Adapters
     class Resque < Base
-      private
-
-      def work_to_do?
+      def queued_count
         queues = redis.smembers("#{namespace}:queues")
         counts = queues.map { |q| redis.llen("#{namespace}:queue:#{q}") }
-        counts.any?(&:nonzero?)
+        counts.inject(&:+) || 0
       end
 
-      def work_being_done?
+      def busy_count
         # No way to tell via redis if work is being done in resque? Booo.
-        false
+        0
       end
 
       def namespace

data/lib/honcho/adapters/sidekiq.rb

@@ -1,20 +1,18 @@
 module Honcho
   module Adapters
     class Sidekiq < Base
-      private
-
-      def work_to_do?
+      def queued_count
         queues = redis.keys("#{namespace}:queue:*")
         counts = queues.map { |q| redis.llen(q) }
-        counts.any?(&:nonzero?)
+        counts.inject(&:+) || 0
       end
 
-      def work_being_done?
+      def busy_count
         processes = redis.smembers("#{namespace}:processes")
         counts = processes.map do |process|
           redis.hget("#{namespace}:#{process}", 'busy').to_i
         end
-        counts.any?(&:nonzero?)
+        counts.inject(&:+) || 0
       end
 
       def namespace

data/lib/honcho/app_status.rb

@@ -0,0 +1,62 @@
+require 'time'
+require 'timeout'
+
+module Honcho
+  class AppStatus
+    def initialize(name, path:)
+      @name = name
+      @path = path
+    end
+
+    def data
+      return {} unless path_exists?
+      threads = [
+        Thread.new { @sha1          = fetch_sha1          },
+        Thread.new { @branch        = fetch_branch        },
+        Thread.new { @commits_ahead = fetch_commits_ahead }
+      ]
+      threads.each(&:join)
+      {
+        sha1:          @sha1,
+        branch:        @branch,
+        commits_ahead: @commits_ahead
+      }
+    end
+
+    private
+
+    def fetch_sha1
+      `cd #{@path} && git rev-parse HEAD 2>/dev/null`.strip
+    end
+
+    def fetch_branch
+      `cd #{@path} && git symbolic-ref --short HEAD 2>/dev/null`.strip
+    end
+
+    REMOTE_REF_STALE_TIME = 60 * 60 # 1 hour
+    FETCH_ORIGIN_TIMEOUT = 3
+
+    def fetch_commits_ahead
+      remote_branch = `cd #{@path} && git rev-parse --symbolic-full-name --abbrev-ref @{u} 2>/dev/null`.strip
+      remote_ref_path = File.join(@path, ".git/refs/remotes/#{remote_branch}")
+      return 0 unless File.exist?(remote_ref_path)
+      if File.stat(remote_ref_path).mtime < Time.now - REMOTE_REF_STALE_TIME
+        begin
+          status = Timeout.timeout(FETCH_ORIGIN_TIMEOUT) do
+            `cd #{@path} && git fetch origin && git status && touch #{remote_ref_path}`
+          end
+        rescue Timeout::Error
+          status = `cd #{@path} && git status`
+        end
+      else
+        status = `cd #{@path} && git status`
+      end
+      return 0 unless status =~ /Your branch is behind.*by (\d+) commits?/
+      $1.to_i
+    end
+
+    def path_exists?
+      File.exist?(@path)
+    end
+  end
+end

data/lib/honcho/colors.rb

@@ -0,0 +1,39 @@
+require 'curses'
+
+module Honcho
+  module Colors
+    COLORS = [
+      [Curses::COLOR_BLUE,    Curses::A_NORMAL],
+      [Curses::COLOR_CYAN,    Curses::A_NORMAL],
+      [Curses::COLOR_GREEN,   Curses::A_NORMAL],
+      [Curses::COLOR_MAGENTA, Curses::A_NORMAL],
+      [Curses::COLOR_RED,     Curses::A_NORMAL],
+      [Curses::COLOR_YELLOW,  Curses::A_NORMAL],
+      [Curses::COLOR_BLUE,    Curses::A_BOLD],
+      [Curses::COLOR_CYAN,    Curses::A_BOLD],
+      [Curses::COLOR_GREEN,   Curses::A_BOLD],
+      [Curses::COLOR_MAGENTA, Curses::A_BOLD],
+      [Curses::COLOR_RED,     Curses::A_BOLD],
+      [Curses::COLOR_YELLOW,  Curses::A_BOLD]
+    ].freeze
+
+    def assign_colors_for_curses
+      COLORS.each_with_index do |(color, _), index|
+        Curses.init_pair(index + 1, color, Curses::COLOR_BLACK)
+      end
+      apps.keys.each_with_index.each_with_object({}) do |(app, index), hash|
+        (_, quality) = COLORS[index]
+        hash[app] = [index + 1, quality]
+      end
+    end
+
+    def assign_colors_for_ansi
+      colors = COLORS.dup
+      apps.keys.each_with_object({}) do |app, hash|
+        (curses_color_code, curses_color_quality) = colors.shift
+        bold = curses_color_quality == Curses::A_BOLD ? 1 : 0
+        hash[app] = "#{bold};3#{curses_color_code}"
+      end
+    end
+  end
+end

data/lib/honcho/passenger_status.rb

@@ -0,0 +1,27 @@
+module Honcho
+  class PassengerStatus
+    def initialize
+      @raw = `passenger-status`
+    rescue
+      raise 'could not execute passenger-status'
+    end
+
+    def data
+      return [] if @raw =~ /not serving any applications/
+      apps = @raw.split(/\-+ Application groups \-+/).last
+      apps.split(/\n\n/).map do |raw_app|
+        next unless (root_match = raw_app.match(/App root: (.+)/))
+        data = {
+          'root' => root_match[1]
+        }
+        data['name'] = data['root'].split('/').last
+        data['workers'] = raw_app.scan(/\* PID.*\n.*/).map do |worker|
+          worker.scan(/([\w ]+?) *: ([\d%MGKhms]+)/).each_with_object({}) do |(key, val), hash|
+            hash[key.strip] = val.strip
+          end
+        end
+        data
+      end.compact.sort_by { |a| a['name'] }
+    end
+  end
+end

data/lib/honcho/runner.rb

@@ -1,28 +1,15 @@
-require 'curses'
 require 'redis'
 require 'time'
 require 'stringio'
 require 'yaml'
 require_relative './adapters'
+require_relative './colors'
 
 Thread.abort_on_exception = true
 
 module Honcho
   class Runner
-    COLORS = {
-      red:            '0;31',
-      green:          '0;32',
-      yellow:         '0;33',
-      blue:           '0;34',
-      magenta:        '0;35',
-      cyan:           '0;36',
-      bright_red:     '1;31',
-      bright_green:   '1;32',
-      bright_yellow:  '1;33',
-      bright_blue:    '1;34',
-      bright_magenta: '1;35',
-      bright_cyan:    '1;36'
-    }.freeze
+    include Colors
 
     def initialize(options)
       @config_file_path = options[:config]
@@ -30,11 +17,12 @@ module Honcho
       @running = {}
       @stopping = {}
       @redis = Redis.new
-      @adapters = build_adapters
-      @colors = assign_colors
+      @adapters_by_app = build_adapters
+      @adapters = @adapters_by_app.values.flatten
+      @colors = assign_colors_for_ansi
     end
 
-    attr_reader :config_file_path, :root_path, :adapters, :running, :stopping, :redis, :colors
+    attr_reader :config_file_path, :root_path, :adapters_by_app, :adapters, :running, :stopping, :redis, :colors
 
     def run
       trap(:INT)  { term_all && exit }
@@ -93,19 +81,12 @@ module Honcho
       @label_width ||= apps.keys.map(&:size).max
     end
 
-    def assign_colors
-      color_values = COLORS.values
-      apps.keys.each_with_object({}) do |app, hash|
-        hash[app] = color_values.shift
-      end
-    end
-
     def build_adapters
-      apps.flat_map do |app, config|
-        config.map do |type, worker_config|
+      apps.each_with_object({}) do |(app, config), hash|
+        hash[app] = config.map do |type, worker_config|
           build_adapter(app, config, type, worker_config)
-        end
-      end.compact
+        end.compact
+      end
     end
 
     def build_adapter(app, config, type, worker_config)

data/lib/honcho/ui_runner/table.rb

@@ -0,0 +1,53 @@
+require 'curses'
+
+module Honcho
+  module UI
+    class Table
+      def initialize(headings:, width:, top:, left:)
+        @headings = headings
+        @width = width
+        @top = top
+        @left = left
+      end
+
+      attr_accessor :width, :headings, :top, :left
+      attr_reader :columns
+
+      def draw(data)
+        draw_headings
+        draw_data(data)
+        Curses.refresh
+      end
+
+      private
+
+      def draw_headings
+        @columns = []
+        column = left
+        Curses.setpos(top, left)
+        headings.each_with_index do |heading, index|
+          @columns[index] = column
+          column += heading.size
+          Curses.addstr(heading)
+        end
+      end
+
+      def draw_data(data)
+        data.each_with_index do |row, row_index|
+          row.each_with_index do |(cell, color_index, color_quality), cell_index|
+            cell_start = columns[cell_index]
+            cell_width = (columns[cell_index + 1] || width) - cell_start
+            Curses.setpos(top + row_index + 1, cell_start)
+            if color_index && color_quality
+              Curses.attron(Curses.color_pair(color_index) | color_quality) do
+                Curses.addstr(cell.to_s.ljust(cell_width))
+              end
+            else
+              Curses.addstr(cell.to_s.ljust(cell_width))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honcho/ui_runner.rb

@@ -0,0 +1,159 @@
+require 'stringio'
+require 'curses'
+require 'sys-uptime'
+require_relative './passenger_status'
+require_relative './ui_runner/table'
+
+module Honcho
+  class UIRunner < Runner
+    def run
+      setup_curses
+      @colors = assign_colors_for_curses
+      init_log_window
+      draw
+      super
+    ensure
+      unsetup_curses
+    end
+
+    def log(name, message)
+      (color_index, color_quality) = colors[name]
+      @log.attron(Curses.color_pair(color_index) | color_quality) do
+        @log.addstr(name.rjust(label_width))
+      end
+      @log.addstr(': ')
+      @log.addstr(message)
+      @log.refresh
+    end
+
+    private
+
+    def init_log_window
+      top = adapters.size + 3
+      @log = Curses::Window.new(lines - top, cols, top, 0)
+      @log.scrollok(true)
+    end
+
+    def draw
+      draw_queues
+      draw_uptime
+    end
+
+    def draw_queues
+      adapter_names = adapters.map(&:name)
+      max_name_width = adapter_names.map(&:size).max
+      bar_width = cols - max_name_width - 80
+      table = UI::Table.new(
+        headings: [
+          'app'.ljust(max_name_width + 2),
+          'webs   ',
+          "req's   ",
+          'sidekiq  ',
+          'resque   ',
+          ' ',
+          'work queue'.ljust(bar_width),
+          ' '
+        ],
+        width: cols - 100,
+        top: 1,
+        left: 2
+      )
+      pstatus = passenger_status
+      data = adapters_by_app.map do |app, adapters|
+        @pstatus_for_app = pstatus[app]
+        count = adapters.map(&:total_count).inject(&:+)
+        sidekiq = adapters.detect { |a| a.type == 'sidekiq' }
+        resque = adapters.detect { |a| a.type == 'resque' }
+        [
+          [app, *colors[app]],
+          [count_web_servers],
+          [count_web_requests],
+          [sidekiq && sidekiq.running? ? 'running' : ''],
+          [resque && resque.running? ? 'running' : ''],
+          ['['],
+          [bar(count, bar_width), 2, 0],
+          [']']
+        ]
+      end
+      table.draw(data)
+    end
+
+    def count_web_servers
+      return unless @pstatus_for_app
+      return unless (busy_webs = @pstatus_for_app['workers'].select { |s| s['Uptime'] }).any?
+      busy_webs.size
+    end
+
+    def count_web_requests
+      return unless @pstatus_for_app
+      @pstatus_for_app['workers'].map { |s| s['Processed'].to_i }.inject(&:+)
+    end
+
+    def draw_uptime
+      x = cols - 38
+      uptime = `uptime`
+      loadavg = uptime.match(/load averages: (.*)/)[1]
+      Curses.setpos(2, x)
+      Curses.attron(Curses.color_pair(2)) do
+        Curses.addstr('Load average: ')
+      end
+      Curses.addstr(loadavg)
+      time = uptime.match(/up (.*), \d+ users/)[1]
+      Curses.setpos(3, x)
+      Curses.attron(Curses.color_pair(2)) do
+        Curses.addstr('Uptime: ')
+      end
+      Curses.addstr(time)
+    end
+
+    def print(text, y = nil, x = nil)
+      if y && x
+        $stdout.print("\033[#{y};#{x}f#{text}")
+      else
+        $stdout.print(text)
+      end
+    end
+
+    def bar(count, width)
+      ('|' * count).ljust(width)[0...width]
+    end
+
+    def check_for_work
+      draw
+      super
+    end
+
+    def lines
+      Curses.lines
+    end
+
+    def cols
+      Curses.cols
+    end
+
+    def setup_curses
+      Curses.init_screen
+      Curses.start_color
+      Curses.cbreak
+      Curses.noecho
+      Curses.curs_set(0)
+      Curses.stdscr.keypad(true)
+    end
+
+    def unsetup_curses
+      Curses.close_screen
+    end
+
+    def show_passenger?
+      return @show_passenger unless @show_passenger.nil?
+      @show_passenger = system('which passenger-status &>/dev/null')
+    end
+
+    def passenger_status
+      return {} unless show_passenger?
+      PassengerStatus.new.data.each_with_object({}) do |app, hash|
+        hash[app['name']] = app
+      end
+    end
+  end
+end

data/lib/honcho.rb

@@ -1 +1,2 @@
 require_relative './honcho/runner'
+require_relative './honcho/ui_runner'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honcho
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Tim Morgn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-23 00:00:00.000000000 Z
+date: 2016-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -52,7 +52,12 @@ files:
 - lib/honcho/adapters/base.rb
 - lib/honcho/adapters/resque.rb
 - lib/honcho/adapters/sidekiq.rb
+- lib/honcho/app_status.rb
+- lib/honcho/colors.rb
+- lib/honcho/passenger_status.rb
 - lib/honcho/runner.rb
+- lib/honcho/ui_runner.rb
+- lib/honcho/ui_runner/table.rb
 homepage: https://github.com/seven1m/honcho
 licenses:
 - MIT