wackamole 0.0.9 → 0.1.2

data/History.txt

@@ -31,4 +31,7 @@
 
 === 0.0.9 /2010-02-28
 * Added console authentication - see README for info
-* Added support for auth on mongo instance - see README for info
+* Added support for auth on mongo instance - see README for info
+
+=== 0.1.0 /2010-03-10
+* Cleaning up

data/README.rdoc

@@ -44,12 +44,14 @@
   
 === Configure It!
 
+  !!! WARNING File format change from 0.1.2 on !!!
+  
   You will need to give wackamole some information about your rackamole configuration. 
-  In order to do so create a .wackamole directory in your home directory and create 
-  a file wackamole.yml. You will need to specify the envs, host and ports specific
+  In order to do so, create a .wackamole directory in your home directory and create 
+  a file zones.yml. You will need to specify the envs, host and ports specific
   to your configuration, but here is a sample.
   
-  wackamole.yml
+  zones.yml
   
     # New ! Optionally you can specify login name and password for the Wackamole web app.
     console_auth: &auth
@@ -57,24 +59,22 @@
         user:     admin
         password: admin
   
-    development:
-      <<:   *auth    
-      host:  localhost
-      port:  27017
-    
-    beta:
-      <<:      *auth    
-      host:     beta_host_name
-      port:     27017
-      user:     bobo
-      password: secret
+    zones:
+      local:
+        host:  localhost
+        port:  27017
+        
+      staging:
+        host:     beta_host_name
+        port:     27017
+        user:     bobo
+        password: secret
     
 === Launch It!  
 
   Watch your creation live! 
 
-  NOTE: By default wackamole uses mongo_rack for storing its session information.
-  This assumes that you have a local mongoDB instance running on the default port 27017.
+  NOTE: By default wackamole uses memcache for storing its session information.
 
   > wackamole
   
@@ -95,7 +95,7 @@
 
     To launch wackamole in a given environment defined in your wackamole.yml configuration.
     
-    > wackamole -e env 
+    > wackamole -e env
     
     This option defaults to production.
     

data/Rakefile

@@ -29,11 +29,11 @@ PROJ.spec.opts   << '--color'
 PROJ.rdoc.include = %w[.rb]
 
 # Dependencies
+depend_on "rack"                  , ">= 1.1.0"
 depend_on "mongo"                 , ">= 0.18.1"
 depend_on "mongo_ext"             , ">= 0.18.1"
 depend_on "agnostic-will_paginate", ">= 3.0.0"
 depend_on "memcache-client"       , ">= 1.5.0"
-depend_on "mongo_rack"            , ">= 0.0.1"
 depend_on "main"                  , ">= 4.2.0"
 depend_on "sinatra"               , ">= 0.9.4"
 depend_on "mongo_rack"            , ">= 0.0.3"

data/bin/wackamole

@@ -19,14 +19,16 @@ Main {
     
   # Enter main loop  
   def run
+puts params[:pool].inspect
+puts params[:environment].inspect
     require File.expand_path( File.join(File.dirname(__FILE__), %w[.. lib wackamole]))
         
     @@options = parse_args( params[:pool].value )
-    ENV['RACK_ENV'] = params['environment'].value
+    ENV['RACK_ENV'] = params[:environment].value
     
     Thread.new do 
       puts "-"*100
-      puts "Initializing Wackamole -- Version #{Wackamole::VERSION} -- Landscape #{params['environment']}"
+      puts "Initializing Wackamole -- Version #{Wackamole::VERSION} -- Landscape #{params[:environment].value}"
       puts "-"*100      
       puts "\n"*2
       puts ">>> Waiting for Franky to warm up..."
@@ -81,4 +83,4 @@ Main {
     end
     opts
   end  
-}
+}

data/lib/app.rb

@@ -5,7 +5,6 @@ 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' ) )
 
@@ -13,14 +12,15 @@ set :public, File.join( File.dirname(__FILE__), %w[.. public] )
 set :views , File.join( File.dirname(__FILE__), %w[.. views] )
 
 def default_config
-  File.join( ENV['HOME'], %w[.wackamole wackamole.yml] )    
+  File.join( ENV['HOME'], %w[.wackamole zones.yml] )    
 end
 
 # -----------------------------------------------------------------------------
 # Configurations
 
 # configure :production do
-#   set :logging, true
+#   set :logging,  true
+#   set :sessions, true
 # end
 
 configure do
@@ -29,8 +29,6 @@ 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
@@ -54,7 +52,7 @@ configure do
     #   :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 )
+  Wackamole::Control.init_config( default_config )
 end
 
 # -----------------------------------------------------------------------------
@@ -77,12 +75,14 @@ before do
     @updated_on   = Time.now
     @refresh_rate = 30
     @app_info     = session[:app_info]
-    begin
-      Wackamole::Control.switch_mole_db!( @app_info[:app_name].downcase, @app_info[:stage] ) if @app_info
-    rescue => boom
-      $stderr.puts boom      
-      @app_info          = nil
-      session[:app_info] = nil
-    end
+    Wackamole::Control.ensure_db( session[:context] ) if session[:context]
+
+    # begin
+    #   Wackamole::Control.switch_mole_db!( @app_info[:app].downcase, @app_info[:stage] ) if @app_info
+    # rescue => boom
+    #   $stderr.puts boom      
+    #   @app_info          = nil
+    #   session[:app_info] = nil
+    # end
   end
 end

data/lib/controllers/dashboard.rb

@@ -5,8 +5,12 @@ module Dashboard
   
   # ---------------------------------------------------------------------------
   # Show application dashboard
-  get '/dashboard/:app_name/:stage' do    
-    Wackamole::Control.switch_mole_db!( params[:app_name].downcase, params[:stage] )
+  get '/dashboard/:zone/:app/:stage' do
+    zone  = params[:zone]
+    app   = params[:app]
+    stage = params[:stage]
+
+    switch_context!( zone, app, stage )
     
     @info = Wackamole::MoledInfo.collect_dashboard_info( @updated_on )
 
@@ -22,6 +26,7 @@ module Dashboard
   # ---------------------------------------------------------------------------
   # Refresh dashboard
   get '/dashboard/refresh' do
+    Wackamole::Control.ensure_db( session[:context] )    
     @info = Wackamole::MoledInfo.collect_dashboard_info( @updated_on )
 
     erb :'dashboard/refresh_js', :layout => false

data/lib/controllers/features.rb

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

data/lib/controllers/logs.rb

@@ -39,7 +39,7 @@ module Logs
   
   # ---------------------------------------------------------------------------
   # Filter logs
-  post "/logs/filter" do    
+  post "/logs/filter" do   
     @filter = Wackamole::SearchFilter.new
     @filter.from_options( params[:filter] )
     session[:filter] = @filter
@@ -47,4 +47,23 @@ module Logs
     @logs = Wackamole::Log.paginate( @filter.to_conds )
     erb :"logs/filter.js", :layout => false
   end  
+  
+  # ---------------------------------------------------------------------------
+  # Show logs for a given user
+  get "/logs/user/:username" do
+    @filter.search_terms = "user:#{params[:username]}"
+    session[:filter] = @filter
+        
+    redirect '/logs/1'
+  end
+  
+  # ---------------------------------------------------------------------------
+  # Show logs for a given feature
+  get "/logs/feature/:feature_id" do
+    @filter.feature_id = params[:feature_id]
+    session[:filter] = @filter
+        
+    redirect '/logs/1'
+  end
+  
 end

data/lib/controllers/mission.rb

@@ -20,8 +20,8 @@ module Mission
     last_tick           ||= Chronic.parse( "#{@refresh_rate} seconds ago" )
     session[:last_tick] = Time.now
     
-    @pulse = Wackamole::Mission.pulse( last_tick )
-              
+    @zones = Wackamole::Mission.pulse( last_tick )
+
     erb :'mission/index'
   end
   
@@ -31,19 +31,18 @@ module Mission
     last_tick           ||= Chronic.parse( "#{@refresh_rate} seconds ago" )
     session[:last_tick] = Time.now
       
-    @pulse = Wackamole::Mission.pulse( last_tick )
+    @zones = Wackamole::Mission.pulse( last_tick )
 
     erb :'/mission/refresh_js', :layout => false
   end
 
   # ---------------------------------------------------------------------------
-  get '/mission/logs/:app_name/:stage/:type' do
-    Wackamole::Control.switch_mole_db!( params[:app_name].downcase, params[:stage] )
+  get '/mission/logs/:zone/:app/:stage/:type' do
+    switch_context!( params[:zone], params[:app], params[:stage] )
     
     # Set app info
-    @app_info = Wackamole::Feature.get_app_info
-    session[:app_info] = @app_info
-
+    load_app_info
+    
     # Reset filter    
     filter = Wackamole::SearchFilter.new
     filter.mole_type( params[:type].to_i )

data/lib/controllers/session.rb

@@ -4,7 +4,6 @@ module Session
   # Check auth
   get "/" do
     if console_auth?
-      # clear_flash!      
       erb :'session/login'
     else 
       redirect '/mission'

data/lib/controllers/users.rb

@@ -4,6 +4,9 @@ module Users
   # Paginate top users
   get "/users/:page" do
     page = params[:page] ? params[:page].to_i : 1
+    
+    Wackamole::Control.ensure_db( session[:context] )
+        
     @users = Wackamole::User.paginate_tops( @filter.to_conds, page )   
 
     @search_path = "/users/search"
@@ -23,7 +26,7 @@ module Users
       @filter.search_terms = params[:search_filter][:search_terms]      
       @users = Wackamole::User.paginate_tops( @filter.to_conds )
     rescue => boom
-      puts boom
+      # puts boom
       @filter.search_terms = nil      
       flash_it!( :error, boom )
       @users = [].paginate
@@ -40,4 +43,5 @@ module Users
     @users = Wackamole::User.paginate_tops( @filter.to_conds )
     erb :"users/filter.js", :layout => false
   end  
+  
 end

data/lib/helpers/dashboard_helper.rb

@@ -13,9 +13,14 @@ module DashboardHelper
     # -------------------------------------------------------------------------  
     # Retrieve moled app info...
     def load_app_info
-      @app_info = Wackamole::Feature.get_app_info
+      tokens = session[:context].split( "." )
+      
+      @app_info = {}
+      @app_info[:zone]  = tokens[0]
+      @app_info[:app]   = tokens[1]
+      @app_info[:stage] = tokens[2]
       session[:app_info] = @app_info
-    end    
+    end
     
     # -------------------------------------------------------------------------
     # Loads the application details

data/lib/helpers/flash_helper.rb

@@ -13,7 +13,6 @@ module FlashHelper
      @flash = session[:flash] || OrderedHash.new
      @flash[type] = msg
      session[:flash] = @flash
-puts @flash.inspect     
    end
  end
 end

data/lib/helpers/main_helper.rb

@@ -15,6 +15,12 @@ module MainHelper
  helpers do   
     include WillPaginate::ViewHelpers::Base   
     
+    # Change mole context and reset connection if need be
+    def switch_context!( zone, app, stage )
+      session[:context] = "#{zone}.#{app}.#{stage}"    
+      Wackamole::Control.current_db( zone, app, stage, true )
+    end
+
     def pluralize( count, name )
       count.to_s + " " + name + (count.to_i > 1 ? "s" : "")
     end

data/lib/helpers/session_helper.rb

@@ -3,17 +3,20 @@ module SessionHelper
     
     # 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']))
+      auth   = config['console_auth']
+      
+      # No auth. Let it go
+      return true unless auth
+      
+      # Validate creds      
+      ((creds['username'] == auth['user']) and (creds['password'] == auth['password']))
     end
     
+    # Check if auth is defined
     def console_auth?
-      env = Sinatra::Application.environment.to_s
       config = YAML.load_file( default_config )
-      conf  = config[env]
-      conf['auth']
+      config['console_auth']
     end
     
     # Check if session has auth

data/lib/wackamole.rb

@@ -1,7 +1,7 @@
 module Wackamole
 
   # :stopdoc:
-  VERSION = '0.0.9'                                                          unless defined? Wackamole::VERSION
+  VERSION = '0.1.2'                                                          unless defined? Wackamole::VERSION
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR unless defined? Wackamole::LIBPATH
   PATH    = ::File.dirname(LIBPATH) + ::File::SEPARATOR                      unless defined? Wackamole::PATH
   # :startdoc:

data/lib/wackamole/models/control.rb

@@ -1,34 +1,38 @@
 require 'mongo'
 require 'logger'
 
+# BOZO !! Refact and clean up duds
 module Wackamole
   class Control
 
     # -----------------------------------------------------------------------
     # Initialize app by reading off mongo configuration parameters if necessary
-    def self.init_config( config_file, env )
+    def self.init_config( config_file )
       begin
-        config  = YAML.load_file( config_file )        
-        @config = config[env]
-        raise "Invalid environment `#{env}" unless @config
-        raise "Unable to find host in - #{@config.inspect}" unless @config.has_key?('host')
-        raise "Unable to find port in - #{@config.inspect}" unless @config.has_key?('port')            
+        @config = YAML.load_file( config_file )
+        raise "Unable to find zones definition" unless @config['zones']
       rescue => boom
         @config = nil          
         raise "Hoy! An error occur loading the config file `#{config_file} -- #{boom}"
       end
       @config
     end
+
+    # -------------------------------------------------------------------------
+    # List all available zones    
+    def self.zones
+      @config['zones'].keys
+    end
     
     # -------------------------------------------------------------------------
     # Defines mole db identity      
-    def self.molex() @molex || /mole_(.*)?_(.*)?_mdb/; end
+    def self.molex() @molex ||= /mole_(.*)?_(.*)?_mdb/; end
         
     # -------------------------------------------------------------------------
     # Fetch a collection on a given database by name
     def self.collection( cltn_name, db_name=nil, opts={:strict => true} )
-      # reset_db!( db_name ) if db_name
-      db( db_name, opts ).collection( cltn_name )
+      raise "Unable to locate current database" unless @db
+      @db.collection( cltn_name )
     end
       
     # -------------------------------------------------------------------------
@@ -39,23 +43,40 @@ module Wackamole
     end
       
     # -------------------------------------------------------------------------
-    # Switch db instance given db_name 
-    # NOTE : This assumes mole db naming convention 
-    # ie mole_{app_name in lower case}_{env}_mdb
-    def self.switch_mole_db!( app_name, env )
-      raise "You must specify an app name and environment" unless app_name and env      
-      app = app_name.gsub( /\s/, '_' ).downcase
+    # Makes sure we're in the right context
+    def self.ensure_db( context )
+      tokens = context.split( "." )
+      current_db( *tokens )
+    end
+        
+    # -------------------------------------------------------------------------
+    # Set current database
+    def self.current_db( zone, app_name, env, reset=false )
+      return @db if @db and !reset
+      app     = app_name.gsub( /\s/, '_' ).downcase
       db_name = to_mole_db( app_name, env )
-      raise "Invalid mole database #{db_name}" unless mole_db?( db_name )      
-      reset_db!( db_name )
-      @db
+      
+      @db = connection( zone ).db( db_name )
     end
     
+    # # -------------------------------------------------------------------------
+    # # Switch db instance given db_name 
+    # # NOTE : This assumes mole db naming convention 
+    # # ie mole_{app_name in lower case}_{env}_mdb
+    # def self.switch_mole_db!( zone, app_name, env )
+    #   raise "You must specify an app name and environment" unless app_name and env      
+    #   app = app_name.gsub( /\s/, '_' ).downcase
+    #   db_name = to_mole_db( app_name, env )
+    #   raise "Invalid mole database #{db_name}" unless mole_db?( zone, db_name )
+    #   reset_db!( zone, db_name )
+    #   @db
+    # end
+    
     # -------------------------------------------------------------------------
     # Inspect current connection databases and weed out mole_xxx databases
-    def self.mole_databases
-      connection.database_names.select do |db_name|
-        db_name if mole_db?( db_name )
+    def self.mole_databases( zone )
+      connection( zone ).database_names.select do |db_name|
+        db_name if mole_db?( zone, db_name )
       end
     end
   
@@ -78,17 +99,17 @@ module Wackamole
 
       # -----------------------------------------------------------------------
       # Checks if this is a mole database  
-      def self.mole_db?( db_name )
+      def self.mole_db?( zone, db_name )
         return false unless db_name =~ molex
-        db    = connection.db( db_name )
-        db.authenticate( config['username'], config['password'] )
+        db    = connection( zone ).db( db_name )
+        db.authenticate( config['username'], config['password'] ) if config['usernane'] and config['password']
         cltns = db.collection_names
         return ((%w[users features logs] & cltns).size == 3)
       end
       
       # -----------------------------------------------------------------------
       # Ensures we have the right db connection
-      def self.reset_db!( db_name )
+      def self.reset_db!( zone, db_name )
         return if @db and @db.name == db_name
         @db = nil
         db( db_name )
@@ -114,22 +135,28 @@ module Wackamole
       
       # -----------------------------------------------------------------------
       # Connects to mongo instance if necessary...
-      def self.connection( log=false )
+      def self.connection( zone, log=false )
+        @connections ||= {}
+        
+        return @connections[zone] if @connections[zone]
+        
         logger = nil
         if log
           logger       = Logger.new($stdout)
           logger.level = Logger::DEBUG
         end
-        @connection ||= Mongo::Connection.new( config['host'], config['port'], :logger => logger )
+
+        host = config['zones'][zone]['host']
+        port = config['zones'][zone]['port']
+        @connections[zone] = Mongo::Connection.new( host, port, :logger => logger )
+        @connections[zone]
       end      
   
       # -----------------------------------------------------------------------
       # Fetch database instance
-      def self.db( db_name=nil, opts={:strict => true} ) 
-        return @db if @db and !db_name
-        return @db if @db and @db.name == db_name
+      def self.db( zone, db_name=nil, opts={:strict => true} ) 
         raise "No database specified" unless db_name
-        @db = connection.db( db_name, opts )
+        connection( zone ).db( db_name, opts )
       end  
     
       # -----------------------------------------------------------------------