wackamole 0.0.8 → 0.0.9

data/History.txt

@@ -27,4 +27,8 @@
 * Bug fixes and clean up
 
 === 0.0.8 /2010-02-21
-* Fix bug on mission and local time
+* Fix bug on mission and local time
+
+=== 0.0.9 /2010-02-28
+* Added console authentication - see README for info
+* Added support for auth on mongo instance - see README for info

data/README.rdoc

@@ -49,12 +49,21 @@
   a file wackamole.yml. You will need to specify the envs, host and ports specific
   to your configuration, but here is a sample.
   
-  wackamole.yml  
+  wackamole.yml
+  
+    # New ! Optionally you can specify login name and password for the Wackamole web app.
+    console_auth: &auth
+      auth:
+        user:     admin
+        password: admin
+  
     development:
-      host: localhost
-      port: 27017
+      <<:   *auth    
+      host:  localhost
+      port:  27017
     
     beta:
+      <<:      *auth    
       host:     beta_host_name
       port:     27017
       user:     bobo

data/bin/wackamole

@@ -7,7 +7,7 @@ URI_MATCH = /(mongo|memcache):\/\/(.+?)\:(\d+)\/(\w+)\/{0,1}(\w*)/
 Main {  
   option( 'pool=[pool]', 'p' ) {
     validate    { |pool| pool =~ URI_MATCH }
-    description "specify session server uri. Must be of the form {[mongo|memcache]}://{host}:{port}/{[database_name|namespace]}[/{collection_name}]"
+    description "specify session server uri. Must be of the form {[mongo|memcache]}://{host}:{port}/{[database_name|namespace]}[/{collection_name}]. Defaults to local memcached on default port"
   }
   option( 'environment', 'e' ) {
     argument :required
@@ -26,7 +26,7 @@ Main {
     
     Thread.new do 
       puts "-"*100
-      puts "Initializing Wackamole -- Version #{Wackamole::VERSION}"
+      puts "Initializing Wackamole -- Version #{Wackamole::VERSION} -- Landscape #{params['environment']}"
       puts "-"*100      
       puts "\n"*2
       puts ">>> Waiting for Franky to warm up..."

data/data/fixtures.rb

@@ -0,0 +1,132 @@
+require "rubygems"
+require "mongo"
+require 'rackamole'
+require 'wackamole'
+
+class Fixtures
+  attr_reader :con
+  
+  def mole_collections() %w(users features logs); end
+    
+  def initialize( host='localhost', port=27099 )
+    puts "Loading fixture data"
+    @con = Mongo::Connection.new( host, port )
+  end
+  
+  def clear
+    con.database_names.select do |db_name|
+      if db_name =~ /^mole_/
+        puts "Dropping db #{db_name}"
+        @con.drop_database( db_name )
+      end
+    end
+  end
+  
+  def populate
+    clear
+    apps = [
+      %w(app1 test),
+      %w(app2 test)
+    ]
+    apps.each { |config| create_mole_db( config.first, config.last ) }
+  end
+
+  def create_mole_db( app_name, env )
+    db_name = mole_db_name( app_name, env )
+    provision( db_name )
+  end
+
+  def provision( db_name )
+    db = con.db( db_name )
+    clear_collections(db) if db
+    
+    populate_features( db )
+    populate_users( db )
+    populate_logs( db )
+  end
+  
+  def populate_features( db )
+    app_name, stage = Wackamole::Control.extract_app_info( db.name )    
+    %w(/ /normal /params/10 /error /slow /post ).each do |ctx|
+      row = { 
+        :app => app_name,
+        :env => stage,
+        :did => Time.now.utc.to_date_id.to_s,
+        :ctx => ctx
+      }
+      db['features'].insert( row )
+    end    
+  end
+  
+  def populate_users( db )
+    %w(fernand bobo bubba eddie freddie).each do |user|
+      row = { :una => user, :did => Time.now.to_date_id }
+      db['users'].insert( row )
+    end
+  end
+  
+  def populate_logs( db )
+    logs_cltn = db['logs']
+    user_config = {
+      'fernand' => {
+        :days       => 2,
+        :activities => [2, 1, 0]
+       },
+      'bobo' => {
+        :days       => 3,
+        :activities => [1, 1, 1]
+       }        
+    }
+    user_config.each_pair do |user_name, activity|
+      user = db['users'].find_one( { :una => user_name } )
+      (0...activity[:days]).each do |day|
+        date = Time.now - day*(24*60*60)
+        count = 0
+        [Rackamole.feature, Rackamole.perf, Rackamole.fault].each do |type|
+          create_logs( db, logs_cltn, activity[:activities][count], type, date.utc, user )
+          count += 1
+        end
+      end 
+    end
+  end
+  
+  def create_logs( db, logs_cltn, count, type, time, user )
+    date_id = time.to_date_id
+    features = db['features'].find( {} ).to_a
+    (0...count).each do |i|
+      time_id = "%02d0100" % (i%23)
+      create_log( logs_cltn, type, date_id, time_id, user, features[i%features.size] )
+    end
+  end
+  
+  def create_log( logs_cltn, type, date_id, time_id, user, feature )
+    row = {
+      :url => "http://localhost:3000#{feature['ctx']}",
+      :typ => type,
+      :fid => feature['_id'],
+      :hos => 'localhost',
+      :met => 'GET',
+      :sts => 200,
+      :did => date_id.to_s,
+      :tid => time_id.to_s,
+      :rti => (type == Rackamole.perf ? 10 : 1),
+      :bro => { :version => '1.0', :name => 'Firefox' },
+      :sof => "thin 1.2.5 codename This Is Not A Web Server",
+      :hdr => { 'Content-Type' => 'text/html', 'Content-Length' => 100 },
+      :par => { :blee => 10, :duh => "bumblebeetuna" },
+      :uid => user['_id'],
+      :mac => { :version => 10.6, :platform => 'Macintosh', :os => 'Intel Mac OS X' },
+      :ses => { :user_name => user['una'] }
+    }
+    logs_cltn.insert( row )
+  end
+      
+  def mole_db_name( app_name, env )
+    "mole_#{app_name}_#{env}_mdb"
+  end
+    
+  def clear_collections( db )
+    mole_collections.each { |cltn| db.drop_collection( cltn ) }
+  end
+end
+# Fixtures.new.populate

data/features/env.rb

@@ -0,0 +1,29 @@
+app_file = File.join( File.dirname(__FILE__), *%w[.. lib app.rb] )
+require app_file
+
+# Force the application name because polyglot breaks the auto-detection logic.
+Sinatra::Application.app_file = app_file
+
+require 'spec/expectations'
+require 'spec/interop/test'
+require 'rack/test'
+require 'sinatra/test'
+require 'capybara'
+
+# Webrat.configure do |config|
+#   config.mode = :rack
+# end
+
+class MyWorld
+  include Rack::Test::Methods
+  # include Webrat::Methods
+  # include Webrat::Matchers
+
+  # Webrat::Methods.delegate_to_session :response_code, :response_body
+
+  def app
+    Sinatra::Application
+  end
+end
+
+World{MyWorld.new}

data/features/mission.feature

@@ -0,0 +1,10 @@
+Feature: Manage moled applications
+  In order to view my application cruise control
+  As a user
+  I want to see all my moled applications
+  
+  Scenario: Moles application list
+    Given I have applications named App1, App2
+    When  I go to the mission
+    Then  I should see App1
+    And   I should see App2

data/features/step_definitions/mission_steps.rb

@@ -0,0 +1,5 @@
+Given /^I have applications named (.+)$/ do |apps|
+  apps.split( ', ' ).each do |app|
+    
+  end
+end

data/lib/app.rb

@@ -5,6 +5,7 @@ require 'mongo'
 gem     'agnostic-will_paginate'
 require 'will_paginate'
 require 'mongo_rack'
+require 'rack-flash'
 require 'rackamole'
 require File.expand_path( File.join( File.dirname(__FILE__), 'wackamole.rb' ) )
 
@@ -18,9 +19,9 @@ end
 # -----------------------------------------------------------------------------
 # Configurations
 
-configure :production do
-  set :logging, true
-end
+# configure :production do
+#   set :logging, true
+# end
 
 configure do
   set :sessions, false
@@ -29,6 +30,8 @@ configure do
   Wackamole.load_all_libs_relative_to(__FILE__, 'helpers' )
   Wackamole.load_all_libs_relative_to(__FILE__, 'controllers' )
  
+  # use Rack::Flash, :accessorize => [:notice, :error]
+  
   #Pick up command line args if any?  
   if defined? @@options and @@options
     if @@options[:protocol] == 'mongo'
@@ -41,18 +44,31 @@ configure do
         :namespace       => @@options[:namespace]
     end
   else
+    # Default is local memcache on default port.
+    use Rack::Session::Memcache, 
+      :memcache_server => "%s:%d" % ['localhost', 11211],
+      :namespace       => 'wackamole'
+    
     # Default is a mongo session store
-    use Rack::Session::Mongo, 
-      :server => "%s:%d/%s/%s" % ['localhost', '27017', 'wackamole_ses', 'sessions'],
-      :log_level => :error
+    # use Rack::Session::Mongo, 
+    #   :server => "%s:%d/%s/%s" % ['localhost', '27017', 'wackamole_ses', 'sessions'],
+    #   :log_level => :error
   end  
   Wackamole::Control.init_config( default_config, Sinatra::Application.environment.to_s )
 end
 
 # -----------------------------------------------------------------------------
 # Before filters
-before do
+before do  
   unless request.path =~ /\.[css gif png js]/
+    if console_auth?
+      unless request.path == '/' or request.path == '/session/create' or request.path == '/session/delete'
+        unless authenticated?
+          redirect '/'
+        end
+      end
+    end
+        
     @filter = session[:filter]
     unless @filter
       @filter = Wackamole::SearchFilter.new

data/lib/controllers/features.rb

@@ -22,8 +22,9 @@ module Features
       @filter.search_terms = params[:search_filter][:search_terms]      
       @features = Wackamole::Feature.paginate_tops( @filter.to_conds )
     rescue => boom
-      logger.error boom
-      flash[:error] = boom
+      puts boom      
+      flash_it!( :error, boom )
+      @filter.search_terms = nil      
       @features = [].paginate
     end
 

data/lib/controllers/logs.rb

@@ -22,6 +22,7 @@ module Logs
       @logs = Wackamole::Log.paginate( @filter.to_conds )
     rescue => boom
       # puts boom
+      @filter.search_terms = nil
       flash_it!( :error, boom )
       @logs = [].paginate
     end

data/lib/controllers/mission.rb

@@ -2,15 +2,25 @@ require 'chronic'
 
 module Mission
   # ---------------------------------------------------------------------------
-  get '/' do
-    # reset app info
+  get '/mission' do
+    clear_flash!
+    
+     # reset app info
     session[:app_info] = @app_info = nil
   
+    # Support store like mongodb where not allowed to peruse connection
+    # in which case just show the dashboard
+    if Wackamole::Control.single_app?
+      app_name, stage = Wackamole::Control.app_info
+      redirect "/dashboard/#{app_name}/#{stage}"
+      return
+    end
+    
     last_tick           = session[:last_tick]
     last_tick           ||= Chronic.parse( "#{@refresh_rate} seconds ago" )
     session[:last_tick] = Time.now
     
-    @pulse = Wackamole::Mission.pulse( last_tick.utc )
+    @pulse = Wackamole::Mission.pulse( last_tick )
               
     erb :'mission/index'
   end
@@ -21,7 +31,7 @@ module Mission
     last_tick           ||= Chronic.parse( "#{@refresh_rate} seconds ago" )
     session[:last_tick] = Time.now
       
-    @pulse = Wackamole::Mission.pulse( last_tick.utc )
+    @pulse = Wackamole::Mission.pulse( last_tick )
 
     erb :'/mission/refresh_js', :layout => false
   end

data/lib/controllers/session.rb

@@ -0,0 +1,32 @@
+module Session
+  
+  # ---------------------------------------------------------------------------
+  # Check auth
+  get "/" do
+    if console_auth?
+      # clear_flash!      
+      erb :'session/login'
+    else 
+      redirect '/mission'
+    end
+  end
+  
+  # ---------------------------------------------------------------------------
+  # Log out  
+  get "/session/delete" do
+    session.clear
+    redirect '/'
+  end
+  
+  # ---------------------------------------------------------------------------
+  # Check credentials
+  post "/session/create" do
+    if authenticate( params[:login] )
+      session[:user] = params[:login][:username]
+      redirect '/mission'
+    else
+      flash_it!( :error, "Authentication failed! Please check credentials." )      
+      redirect '/'
+    end
+  end
+end

data/lib/controllers/users.rb

@@ -23,8 +23,9 @@ module Users
       @filter.search_terms = params[:search_filter][:search_terms]      
       @users = Wackamole::User.paginate_tops( @filter.to_conds )
     rescue => boom
-      logger.error boom
-      flash[:error] = boom
+      puts boom
+      @filter.search_terms = nil      
+      flash_it!( :error, boom )
       @users = [].paginate
     end
 

data/lib/helpers/flash_helper.rb

@@ -2,15 +2,18 @@ module FlashHelper
  helpers do
    
    # clear out flash object
-   def clear_it!
+   def clear_flash!
      @flash = session[:flash] || OrderedHash.new     
      @flash.clear
+     session[:flash] = @flash
    end
    
    # add flash message
    def flash_it!( type, msg )
      @flash = session[:flash] || OrderedHash.new
      @flash[type] = msg
+     session[:flash] = @flash
+puts @flash.inspect     
    end
  end
 end

data/lib/helpers/logs_helper.rb

@@ -79,7 +79,8 @@ module LogsHelper
      
     # ---------------------------------------------------------------------------
     # Trim out extra host info if any
-    def format_host( host )    
+    def format_host( host )
+      return "n/a" unless host or host.empty?      
       return host.split( "." ).first if host.index( /\./ )
       host
     end

data/lib/helpers/session_helper.rb

@@ -0,0 +1,29 @@
+module SessionHelper  
+  helpers do
+    
+    # Check credentials against config file
+    def authenticate( creds )
+      env = Sinatra::Application.environment.to_s
+      config = YAML.load_file( default_config )
+      conf  = config[env]      
+      ((creds['username'] == conf['auth']['user']) and (creds['password'] == conf['auth']['password']))
+    end
+    
+    def console_auth?
+      env = Sinatra::Application.environment.to_s
+      config = YAML.load_file( default_config )
+      conf  = config[env]
+      conf['auth']
+    end
+    
+    # Check if session has auth
+    def authenticated?
+      session[:user]
+    end
+    
+    # check for login path
+    def root_path?
+      request.path == "/"
+    end
+  end
+end