gltail 0.0.7

data/lib/gl_tail/blob_store.rb

@@ -0,0 +1,43 @@
+class BlobStore
+  @store = { }
+  @used_keys = { }
+  def self.get(key)
+    @used_keys[key] = true
+    return @store[key]
+  end
+
+  def self.put(key, ob)
+    @store[key] = ob
+    @used_keys[key] = true
+  end
+
+  def self.has(key)
+    @store.include? key
+  end
+
+  def self.size
+    @store.size
+  end
+
+  def self.used
+    @used_keys.size
+  end
+
+  def self.prune
+    @store.keys.each do |k|
+      unless @used_keys.include? k
+        glDeleteLists(@store[k], 1)
+        @store.delete k
+      end
+    end
+    @used_keys = { }
+  end
+
+  def self.empty
+    @store.keys.each do |k|
+      glDeleteLists(@store[k], 1)
+      @store.delete k
+    end
+    @used_keys = { }
+  end
+end

data/lib/gl_tail/block.rb

@@ -0,0 +1,130 @@
+# gl_tail.rb - OpenGL visualization of your server traffic
+# Copyright 2007 Erlend Simonsen <mr@fudgie.org>
+#
+# Licensed under the GNU General Public License v2 (see LICENSE)
+#
+
+class Block
+  include GlTail::Configurable
+
+  attr_reader :name, :bottom_position
+
+  config_attribute :color, "FIXME: add description", :type => :color
+  config_attribute :order, "FIXME"
+  config_attribute :size, "FIXME"
+  config_attribute :auto_clean
+
+  attr_accessor :column
+  attr_reader :config
+
+  def initialize(config, name)
+    @config = config
+    @name = name
+
+    @size = 10
+    @auto_clean = true
+    @order = 100
+#    @color = [1.0, 1.0, 1.0, 1.0]
+
+    @show = 0
+
+    @header = Element.new(self, @name.upcase)
+    @header.color = [1.0, 1.0, 1.0, 1.0]
+
+    @elements = { }
+    @bottom_position = -@config.screen.top
+  end
+
+  def show=(value)
+    @show = case value
+    when 'rate' then 0
+    when 'total' then 1
+    when 'average' then 2
+    else
+      0
+    end
+  end
+
+  attr_reader :show
+
+  def top
+    @config.screen.top
+  end
+
+  def line_size
+    @config.screen.line_size
+  end
+
+  def is_right
+    column.is_right
+  end
+
+  def alignment
+    column.alignment
+  end
+
+  def position
+    column.position
+  end
+
+  def width
+    column.size
+  end
+
+  def render(engine, num)
+    return num if @elements.size == 0
+
+    @header.wy = top - (num * line_size)
+    #    @header.y = @header.wy if @header.y == -$CONFIG.top
+    @header.render(engine)
+    num += 1
+
+    sorted = case @show
+    when 0: @elements.values.sort { |k,v| v.rate <=> k.rate}[0..@size-1]
+    when 1: @elements.values.sort { |k,v| v.total <=> k.total}[0..@size-1]
+    when 2: @elements.values.sort { |k,v| v.average <=> k.average}[0..@size-1]
+    end
+
+    sorted.each do |e|
+      e.wy = top - (num * line_size)
+      e.render(engine)
+      engine.stats[0] += 1
+      if e.rate <= 0.0001 && e.active && e.updates > 59 && @auto_clean
+        @elements.delete(e.name)
+      end
+      num += 1
+    end
+
+    (@elements.values - sorted).each do |e|
+      engine.stats[0] += 1
+      e.activities.each do |a|
+        a.render(engine)
+        if a.x > 1.0 || a.x < -1.0 || a.y > @config.screen.aspect
+          e.activities.delete a
+        end
+      end
+      if e.activities.size == 0 && @auto_clean && e.updates > 59
+        @elements.delete(e.name)
+      end
+    end
+    @elements.delete_if { |k,v| (!sorted.include? v) && v.active && v.activities.size == 0 && v.updates > 29} if @auto_clean
+    @bottom_position = top - ((sorted.size > 0 ? (num-1) : num) * line_size)
+    num + 1
+  end
+
+  def add_activity(options = { })
+    x = @elements[options[:name]] ||= Element.new(self, options[:name])
+    x.add_activity(options[:message], @color || options[:color] , options[:size] || 0.01, options[:type] || 0 )
+  end
+
+  def add_event(options = { })
+    x = @elements[options[:name]] ||= Element.new(self, options[:name])
+    x.add_event(options[:message], options[:color] || @color, options[:update_stats] || false)
+  end
+
+  def update
+    @elements.each_value do |e|
+      e.update
+    end
+  end
+end

data/lib/gl_tail/config.rb

@@ -0,0 +1,187 @@
+
+module GlTail
+  CONFIG_OPTIONS = { }
+
+  COLORS = {
+    'white'   => %w{ 255 255 255 255 },
+    'red'     => %w{ 255   0   0 255 },
+    'green'   => %w{   0 255   0 255 },
+    'blue'    => %w{   0   0 255 255 },
+    'yellow'  => %w{ 255 255   0 255 },
+    'cyan'    => %w{   0 255 255 255 },
+    'magenta' => %w{ 255   0 255 255 },
+
+    'purple'  => %w{ 128   0 255 255 },
+    'orange'  => %w{ 255 128   0 255 },
+    'pink'    => %w{ 255   0 128 255 },
+  }
+
+  class Screen
+    include Configurable
+
+    config_attribute :wanted_fps, "FIXME: add description"
+
+    config_attribute :min_blob_size, "Minimum size of activity indicators [0.0 - 1.0]"
+    config_attribute :max_blob_size, "Maximum size of activity indicators [0.0 - 1.0]"
+
+    # shortcut to set these via dimensions
+    config_attribute :window_width, "Width of GlTail window"
+    config_attribute :window_height, "Height of GlTail window"
+
+    config_attribute :mode, "FIXME"
+    config_attribute :bounce, "FIXME"
+
+    config_attribute :highlight_color, "FIXME: add description", :type => :color
+
+    attr_accessor :aspect, :line_size, :top, :bitmap_mode
+
+    def initialize(config)
+      @config = config
+
+      @wanted_fps = 0
+      @aspect = 0.6
+      @bounce = false
+
+      @top = 0.9
+      @line_size = 0.03
+      @bitmap_mode = 0
+      @mode = 0
+      @highlight_color = [1.0, 0.0, 0.0, 1.0]
+    end
+
+    def set_dim(x, y)
+      self.window_width = x.to_i
+      self.window_height = y.to_i
+    end
+
+
+    def dimensions=(dim)
+      if dim.is_a?(String)
+        case dim
+        when /^(\d+)x(\d+)$/
+          set_dim $1, $2
+        when /^(\d+), (\d+)$/
+          set_dim $1, $2
+        else
+          raise "dimensions not understood #{dim}, please use <width>x<height> or <width>, <height>"
+        end
+      else
+        raise "what are you #{dim.inspect}"
+      end
+    end
+
+    def right
+      @right ||= Column.new(@config, :right)
+    end
+
+    def left
+      @left ||= Column.new(@config, :left)
+    end
+
+  end
+
+  class Column
+    include Configurable
+
+    config_attribute :size, "FIXME: add description"
+    config_attribute :alignment, "FIXME: add description"
+
+    def initialize(config, which)
+      @config = config
+      @which = which
+    end
+
+    def is_right
+      @which == :right
+    end
+  end
+
+  class Config
+    class << self
+      def parse_yaml(file)
+        require 'yaml'
+
+        YamlParser.new(file).apply(self.new)
+      end
+    end
+
+    attr_reader :sources
+
+    def initialize
+      @sources = []
+      @blocks = []
+      @max_size = 1.0
+    end
+
+    def screen
+      @screen ||= Screen.new(self)
+    end
+
+    def blocks
+      @blocks
+    end
+
+    def add_block(name)
+      @blocks << b = Block.new(self, name)
+      b
+    end
+
+    def reshape(w, h)
+      screen.aspect = h.to_f / w.to_f
+      screen.window_width, screen.window_height = w, h
+    end
+
+    def do_process
+      active = 0
+
+      sources.each do |it|
+        active += 1
+        it.process
+      end
+
+      active
+    end
+
+    def update
+      sources.each { |it| it.update }
+      blocks.each { |it| it.update }
+      @max_size = @max_size * 0.99 if(@max_size * 0.99 > 1.0)
+    end
+
+    def init
+      sources.each { |it| it.init }
+
+      @blocks_by_name = {}
+
+      blocks.each do |it|
+        @blocks_by_name[it.name] = it
+      end
+    end
+
+    #block, message, size
+    def add_activity(source, options = { })
+      size = screen.min_blob_size
+      if options[:size]
+        size = options[:size].to_f
+        @max_size = size if size > @max_size
+        size = screen.min_blob_size + ((size / @max_size) * (screen.max_blob_size - screen.min_blob_size))
+        options[:size] = size
+      end
+
+      if block = @blocks_by_name[options[:block]]
+        block.add_activity({
+          :name => source.name,
+          :color => source.color,
+          :size => screen.min_blob_size
+          }.update(options) )
+      end
+    end
+
+    #block, message
+    def add_event(source, options = { })
+      if block = @blocks_by_name[options[:block]]
+        block.add_event( { :name => source.name, :color => source.color, :size => screen.min_blob_size}.update(options) )
+      end
+    end
+  end
+end

data/lib/gl_tail/config/configurable.rb

@@ -0,0 +1,51 @@
+module GlTail
+
+  module Configurable
+
+    module ClassMethods
+      def config_attribute(id, description = "", opts = {})
+
+        rewrite_method = case opts[:type]
+        when :color
+          "config_rewrite_color"
+        else
+          ""
+        end
+
+        self.class_eval %{
+          def #{id}=(value)
+            @#{id} = #{rewrite_method} value
+          end
+
+          def #{id}
+            @#{id}
+          end
+        }
+
+        doc = GlTail::CONFIG_OPTIONS[self.to_s] ||= {}
+        doc[id] = {
+          :description => description,
+        }.update(opts)        
+      end
+    
+    end
+
+    def config_rewrite_color(v)
+      case v
+      when /(.+),(.+),(.+),(.+)/
+        value = v.split(',')
+      else
+        value = GlTail::COLORS[v.downcase]
+        unless value
+          raise SyntaxError, "You must use either [#{GlTail::COLORS.keys.sort.join('|')}] or a color in RGBA format."
+        end
+        value.map! { |x| x.to_i / 255.0 }
+      end
+      value.map {|x| x.to_f }
+    end
+
+    def self.included(receiver)
+      receiver.extend ClassMethods
+    end
+  end
+end

data/lib/gl_tail/config/yaml_parser.rb

@@ -0,0 +1,94 @@
+require 'yaml'
+
+module GlTail
+  class YamlParser
+    attr_reader :yaml
+
+    def initialize file
+      file  ||= "config.yaml"
+      @yaml   = YAML.load_file(file)
+    end
+
+    def apply(config)
+      @config = config
+
+      @left   = Hash.new
+      @right  = Hash.new
+      @blocks = Array.new
+
+      parse_servers
+      parse_config
+      parse_resolver
+
+      @config
+    end
+    
+    def parse_resolver
+      if x = self.yaml['resolver']
+        x.each do |k, v|
+          apply_value(Resolver.instance, k, v )
+        end
+      end
+    end
+
+    def parse_servers
+
+      self.yaml['servers'].each do |server|
+
+        src = GlTail::Source::SSH.new(@config)
+
+        src.name = server.shift
+
+        apply_values(src, server.shift)
+
+        @config.sources << src
+      end
+    end
+
+    def apply_values(target, hash)
+      hash.each do |key, value|
+        apply_value(target, key, value)
+      end
+    end
+
+    def apply_value(target, key, value)
+      begin
+        target.send("#{key}=", value)
+      rescue
+        puts "FAILED TO APPLY #{key}=#{value} TO #{target}"
+        raise
+      end
+    end
+
+    def parse_config
+      self.yaml['config'].each do |key, config|
+        screen = @config.screen
+
+        case config
+        when Hash
+          if key =~ /(left|right)_column/
+            column = screen.send($1)
+            blocks = config.delete('blocks')
+
+            apply_values(column, config)
+            add_blocks(column, blocks)
+          else
+            target = screen.send(key)          
+            apply_values(target, config)
+          end
+        else
+          apply_value(screen, key, config)
+        end
+      end
+    end
+
+    def add_blocks(column, hash)
+      hash.each do |key, config|
+        block = @config.add_block(key)
+        block.column = column
+        
+        apply_values(block, config)
+      end
+    end
+  end
+end