clarity 0.9.0

data/lib/clarity/renderers/log_renderer.rb

@@ -0,0 +1,47 @@
+require 'action_view'
+require 'uri'
+
+class LogRenderer
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::UrlHelper
+  
+  Prefix   = ""
+  Suffix   = "<br/>\n"
+  TagOrder = [ :timestamp, :shop, :labels, :line ]
+  MarkTime = 60 * 5 # 5 minutes
+
+  def initialize()
+    @last_timestamp = nil
+  end
+  
+  def render(elements = {})
+    @elements = elements
+    @tags = []
+    TagOrder.each do |tag|
+      if content = @elements.fetch(tag, nil)
+        method  = ("tag_"+tag.to_s).to_sym
+        @tags << self.send(method, content)
+      end
+    end
+    
+    @tags.empty? ? "" : Prefix + @tags.join(" ").to_s + Suffix
+  end
+  
+    
+  def tag_timestamp(content, options = {})
+    content + " : "
+  end
+  
+  def tag_line(content, options = {})
+    ERB::Util.h(content)
+  end
+  
+  def tag_shop(content, options = {})
+    "[<a href='http://#{URI.escape(content)}'>#{content}</a>]"
+  end
+  
+  def tag_labels(content, options = {})
+    "[#{content}]"
+  end
+
+end

data/lib/clarity/server.rb

@@ -0,0 +1,143 @@
+require 'cgi'
+require File.dirname(__FILE__) + '/server/basic_auth'
+require File.dirname(__FILE__) + '/server/mime_types'
+require File.dirname(__FILE__) + '/server/chunk_http'
+require File.dirname(__FILE__) + '/grep_renderer'
+
+module Clarity
+  class NotFoundError < StandardError; end
+  class NotAuthenticatedError < StandardError; end
+  class InvalidParameterError < StandardError; end
+
+  module Server
+    include EventMachine::HttpServer
+    include Clarity::BasicAuth
+    include Clarity::ChunkHttp
+    
+    attr_accessor :required_username, :required_password
+    attr_accessor :log_files    
+    
+    def self.run(options)
+      EventMachine::run do
+        EventMachine.epoll
+        EventMachine::start_server(options[:address], options[:port], self) do |a|
+          a.log_files = options[:log_files]
+          a.required_username = options[:username]
+          a.required_password = options[:password]
+        end
+        STDERR.puts "Listening #{options[:address]}:#{options[:port]}..."
+        STDERR.puts "Adding log files: #{options[:log_files].inspect}"
+      end      
+    end
+
+    def process_http_request    
+      authenticate!
+
+      puts "action: #{path}"
+      puts "params: #{params.inspect}"
+
+      case path
+      when '/'
+        respond_with(200, welcome_page)
+
+      when '/perform'
+        if params.empty?
+          respond_with(200, welcome_page)
+        else
+          # get command
+          command = case params['tool']
+            when 'grep' then CommandBuilder.new(params).command
+            when 'tail' then TailCommandBuilder.new(params).command
+            else raise InvalidParameterError, "Invalid Tool parameter"
+          end
+          response = respond_with_chunks
+          response.chunk results_page # display page header
+
+          puts "Running: #{command}"
+          EventMachine::popen(command, GrepRenderer) do |grepper|
+            @grepper = grepper          
+            @grepper.marker = 0
+            @grepper.params = params
+            @grepper.response = response 
+          end
+        end
+
+      when '/test'
+        response = init_chunk_response
+        EventMachine::add_periodic_timer(1) do 
+          response.chunk "Lorem ipsum dolor sit amet<br/>"        
+          response.send_chunks
+        end
+
+      else                          
+        respond_with(200, public_file(path), :content_type => Mime.for(path))
+      end
+
+    rescue InvalidParameterError => e
+      respond_with(500, error_page(e))
+    rescue NotFoundError => e
+      respond_with(404, "<h1>Not Found</h1>")
+    rescue NotAuthenticatedError => e
+      puts "Could not authenticate user"
+      headers = { "WWW-Authenticate" => %(Basic realm="Clarity")}
+      respond_with(401, "HTTP Basic: Access denied.\n", :content_type => 'text/plain', :headers => headers)
+    end    
+    
+    def error_page(error)
+      @error = error
+      render "error.html.erb"
+    end
+
+    def welcome_page
+      render "index.html.erb"
+    end
+
+    def results_page
+      render "index.html.erb"
+    end
+
+    def unbind
+      return unless @grepper
+      kill_processes(@grepper.get_status.pid)
+      close_connection
+    end
+
+    def kill_processes(ppid)
+      return if ppid.nil?
+      all_pids = [ppid] + get_child_pids(ppid).flatten.uniq.compact
+      puts "=== pids are #{all_pids.inspect}"
+      all_pids.each do |pid|
+        Process.kill('TERM',pid.to_i)
+        puts "=== killing #{pid}"
+      end
+    rescue Exception => e
+      puts "!Error killing processes: #{e}"
+    end
+
+    def get_child_pids(ppid)
+      out = `ps -opid,ppid | grep #{ppid.to_s}`
+      ids = out.split("\n").map {|line| $1 if line =~ /^\s*([0-9]+)\s.*/ }.compact
+      ids.delete(ppid.to_s)
+      if ids.empty?
+        ids
+      else
+        ids << ids.map {|id| get_child_pids(id) }
+      end
+    end
+
+    private
+
+    def authenticate!
+      login, pass = authentication_data
+
+      if (required_username && required_username != login) || (required_password && required_password != pass)    
+        raise NotAuthenticatedError
+      end
+
+      true
+    end
+
+  end
+
+
+end

data/lib/clarity/server/basic_auth.rb

@@ -0,0 +1,24 @@
+module Clarity
+  module BasicAuth
+
+    def decode_credentials(request)
+      Base64.decode64(request).split.last
+    end
+    
+    def user_name_and_password(request)
+      decode_credentials(request).split(/:/, 2)
+    end
+  
+    def authentication_data
+      headers = @http_headers.split("\000")
+      auth_header = headers.detect {|head| head =~ /Authorization: / }
+      header = auth_header.nil? ? "" : auth_header.split("Authorization: Basic ").last    
+      return (user_name_and_password(header) rescue ['', ''])
+    end
+  
+    def authenticate!(http_header)
+      raise NotAuthenticatedError unless authenticate(http_header)
+    end
+  
+  end
+end

data/lib/clarity/server/chunk_http.rb

@@ -0,0 +1,57 @@
+module Clarity
+  
+  module ChunkHttp
+    
+    LeadIn    = ' ' * 1024    
+    
+    def respond_with_chunks
+      response = EventMachine::DelegatedHttpResponse.new( self )
+      response.status = 200
+      response.headers['Content-Type'] = 'text/html'
+      response.chunk LeadIn
+      response
+    end
+
+    def respond_with(status, content, options = {})
+      response = EventMachine::DelegatedHttpResponse.new( self )
+      response.headers['Content-Type'] = options.fetch(:content_type, 'text/html')
+      response.headers['Cache-Control'] = 'private, max-age=0'
+      headers = options.fetch(:headers, {})
+      headers.each_pair {|h, v| response.headers[h] = v }
+      response.status  = status
+      response.content = content
+      response.send_response
+    end    
+
+    def render(view)
+      @toolbar = template("_toolbar.html.erb")
+      @content_for_header = template("_header.html.erb")
+      template(view)
+    end
+
+    def template(filename)
+      content = File.read( File.join(Clarity::Templates, filename) ) 
+      ERB.new(content).result(binding)
+    end
+
+    def public_file(filename)
+      File.read( File.join(Clarity::Public, filename) ) 
+    rescue Errno::ENOENT
+      raise NotFoundError
+    end
+
+    def logfiles
+      log_files.map {|f| Dir[f] }.flatten.compact.uniq.select{|f| File.file?(f) }.sort
+    end
+        
+    def params
+      ENV['QUERY_STRING'].split('&').inject({}) {|p,s| k,v = s.split('=');p[k.to_s] = CGI.unescape(v.to_s);p}
+    end  
+
+    def path
+      ENV["PATH_INFO"]
+    end
+    
+  end
+  
+end

data/lib/clarity/server/mime_types.rb

@@ -0,0 +1,23 @@
+module Clarity
+  module Mime
+    def self.for(filename)
+      
+      content_type = TYPES[File.extname(filename)] 
+      content_type || 'text/plain'
+    end
+    
+    TYPES = {
+      '.jpg'    =>  'image/jpg', 
+      '.jpeg'   =>  'image/jpeg',
+      '.gif'    =>  'image/gif', 
+      '.png'    =>  'image/png',
+      '.bmp'    =>  'image/bmp',
+      '.bitmap' =>  'image/x-ms-bmp',
+      '.js'     => 'application/javascript',
+      '.txt'    => 'text/plain',
+      '.css'    => 'text/css',
+      '.html'   => 'text/html',
+      '.htm'    => 'text/html'
+    }
+  end
+end

data/public/javascripts/app.js

@@ -0,0 +1,154 @@
+/* ----------------------------------------------------------------------------
+ * Log Search Server JS
+ * by John Tajima
+ * requires jQuery 1.3.2
+ * ----------------------------------------------------------------------------
+ */
+
+
+var Search = {
+  search_form  : 'search',                        // domId of the form
+  resultsId    : 'results',
+  search_fields: [ 'term1', 'term2', 'term3' ],   // domIds of search term fields
+  file_list    : 'file-list',                     // domId of select for logfiles
+  logfiles     : {},                              // hash of log files
+  past_params  : null,                            // recent request
+  url          : '/perform',  
+  scroll_fnId  : null,                    
+
+  // initialize Search form
+  // { 'grep': [ log, files, for, grep], 'tail': [ 'log', 'files', 'for', 'tail']}
+  init: function(logfiles, params) {
+    this.logfiles    = logfiles;
+    this.past_params = params;
+    
+    this.bind_grep_tool();
+    this.bind_tail_tool();
+    this.bind_options();
+    
+    if (!this.past_params) return; // return if no prev settings, nothing to set
+
+    // init tool selector
+    (this.past_params['tool'] == 'grep') ? $('#grep-label').trigger('click') :  $('#tail-tool').trigger('click'); 
+    
+    // init log file selector
+    $('#'+this.file_list).val(this.past_params['file']);
+
+    // init search fields
+    jQuery.each(this.search_fields, function(){
+      $('#'+this).val(Search.past_params[this]);
+    }); 
+    
+    // advanced options usd?
+    // time was set - so show advanced options
+    if ((this.past_params['sh']) || (this.past_params['eh'])) {
+      this.showAdvanced();
+      if (this.past_params['sh']) {
+        jQuery.each(['sh', 'sm', 'ss'], function(){ $('#'+this).val(Search.past_params[this])  });        
+      }
+      if (this.past_params['eh']) {
+        jQuery.each(['eh', 'em', 'es'], function(){ $('#'+this).val(Search.past_params[this])  });        
+      }      
+    }
+       
+  },
+
+  // bind option selectors
+  bind_options: function() {
+    $('#auto-scroll').bind('change', function(){
+        Search.autoScroll(this.checked);
+    });
+    $('#auto-scroll').attr('checked', true).trigger('change'); // by default, turn on
+  },
+  
+  // bind change grep tool
+  bind_grep_tool: function() {
+    $('#grep-tool').bind('change', function(e){
+      var newlist = ""
+      jQuery.each(Search.logfiles['grep'], function(){
+        newlist += "<option value='" + this + "'>" + this + "</option>\n"
+      });
+      $('#'+Search.file_list).html(newlist);
+    });
+    // watch clicking label as well
+    $('#grep-label').bind('click', function(e){ 
+      $('#grep-tool').attr('checked', 'checked').val('grep').trigger('change');
+    });
+  },
+  
+  
+  // bind change tail tool
+  bind_tail_tool: function() {
+    $('#tail-tool').bind('change', function(e){
+      var newlist = ""
+      jQuery.each(Search.logfiles['tail'], function(){
+        newlist += "<option value='" + this + "'>" + this + "</option>\n"
+      });
+      $('#'+ Search.file_list).html(newlist);
+    });
+    // watch clicking label as well
+    $('#tail-label').bind('click', function(e){ 
+      $('#tail-tool').attr('checked', 'checked').val('tail').trigger('change');
+    });
+  },
+  
+  
+  // clears the terms fields
+  clear: function() {
+    jQuery.each(this.search_fields, function(){
+      $('#'+this).val("");
+    });
+  },
+  
+  showAdvanced: function() {
+    $('#enable-advanced').hide();
+    $('#disable-advanced').show();
+    $('.advanced-options').show();
+  },
+  
+  hideAdvanced: function() {
+    this.clearAdvanced();
+    $('#enable-advanced').show();
+    $('#disable-advanced').hide();
+    $('.advanced-options').hide();
+  },
+  
+  clearAdvanced: function() {
+    $('#advanced-options input').val("");
+  },
+  
+  // gathers form elements and submits to proper url
+  submit: function() {
+    $('#'+this.search_form).submit();
+    $('#'+this.resultsId).html("Sending new query..."); 
+  },
+  
+  //
+  // Misc utitilies
+  //
+
+  autoScroll: function(enabled) {    
+    if (enabled == true) {
+      if (this.scroll_fnId) return; // already running
+
+      //console.log("scroll ON!")
+      window._currPos = 0; // init pos
+      this.scroll_fnId = setInterval( function(){
+        if (window._currPos < document.height) {
+          window.scrollTo(0, document.height);
+          window._currPos = document.height;
+        }
+      }, 100 );
+    } else {
+      if (!this.scroll_fnId) return; 
+      //console.log("scroll off")
+      if (this.scroll_fnId) {
+        clearInterval(this.scroll_fnId);
+        window._currPost = 0;
+        this.scroll_fnId = null;
+      }
+    }    
+  }
+  
+};
+