wackamole 0.0.1

data/lib/helpers/rails_helper.rb

@@ -0,0 +1,7 @@
+# module RailsHelper
+#   
+#   helpers do
+#     include Wackamole::TagHelper
+#     include Wackamole::FormHelper    
+#   end
+# end

data/lib/wackamole.rb

@@ -0,0 +1,47 @@
+module Wackamole
+
+  # :stopdoc:
+  VERSION = '0.0.1'                                                          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:
+
+  # Returns the version string for the library.
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+  # Utility to force class load
+  def self.load_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+    Dir.glob(search_me).sort.each {|rb| load rb}
+  end
+
+end
+
+Wackamole.require_all_libs_relative_to(__FILE__)

data/lib/wackamole/core_ext/date_time.rb

@@ -0,0 +1,8 @@
+class DateTime
+  
+  # ---------------------------------------------------------------------------
+  # Convert a datetime to an id ie => 20100101
+  def to_date_id
+    self.strftime( "%Y%m%d").to_i
+  end  
+end

data/lib/wackamole/core_ext/time.rb

@@ -0,0 +1,9 @@
+class Time  
+  def to_date_id
+    self.strftime( "%Y%m%d").to_i
+  end
+  
+  def to_time_id
+    "%02d%02d%02d" % [self.hour, self.min, self.sec]
+  end
+end

data/lib/wackamole/models/control.rb

@@ -0,0 +1,132 @@
+require 'mongo'
+require 'logger'
+
+module Wackamole
+  class Control
+    
+    # -------------------------------------------------------------------------
+    # Defines mole db identity      
+    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 )
+    end
+      
+    # -------------------------------------------------------------------------
+    # extract app_name + env from db_name
+    def self.extract_app_info( db_name )
+      raise "Invalid mole db specification #{db_name}" unless db_name =~ molex
+      db_name.match( molex ).captures
+    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
+      db_name = to_mole_db( app_name, env )
+      raise "Invalid mole database #{db_name}" unless mole_db?( db_name )      
+      reset_db!( 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 )
+      end
+    end
+  
+    # =========================================================================
+    private
+  
+      # -----------------------------------------------------------------------
+      # Computes mole_db name from app and env
+      def self.to_mole_db( app_name, env )
+        "mole_%s_%s_mdb" % [app_name, env] 
+      end
+      
+      # -----------------------------------------------------------------------
+      # Reset connection. For testing only!
+      def self.reset!
+        @connection.close if @connection
+        @connection = nil
+        @config     = nil
+      end
+
+      # -----------------------------------------------------------------------
+      # Checks if this is a mole database  
+      def self.mole_db?( db_name )
+        return false unless db_name =~ molex
+        db    = connection.db( db_name )
+        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 )
+        return if @db and @db.name == db_name
+        @db = nil
+        db( db_name )
+      end
+
+      # -----------------------------------------------------------------------
+      # Initialize app by reading off mongo configuration parameters if necessary
+# BOZO !!      
+# File.join( ENV['HOME'], %w[.wackamole wackamole.yml] )
+# 
+      def self.init_config( config_file, env )
+        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')            
+        rescue => boom
+          @config = nil          
+          raise "Hoy! An error occur loading the config file `#{config_file} -- #{boom}"
+        end
+        @config
+      end
+      
+      def self.config
+        raise "You must call init_config before using this object" unless @config
+        @config
+      end
+    
+      # -----------------------------------------------------------------------
+      # Connects to mongo instance if necessary...
+      def self.connection( log=false )
+        logger = nil
+        if log
+          logger       = Logger.new($stdout)
+          logger.level = Logger::DEBUG
+        end
+        @connection ||= Mongo::Connection.new( config['host'], config['port'], :logger => logger )
+      end      
+  
+      # -----------------------------------------------------------------------
+      # Fetch database instance
+      def self.db( db_name=nil, opts={:strict => true} )
+# puts "#{db_name} -- #{@db.inspect}"        
+        return @db if @db and !db_name
+        return @db if @db and @db.name == db_name
+        raise "No database specified" unless db_name
+        @db = connection.db( db_name, opts )
+        ensure_indexes
+        @db
+      end  
+    
+      # -----------------------------------------------------------------------
+      # Make sure the right indexes are set
+      def self.ensure_indexes
+      end
+  end
+end

data/lib/wackamole/models/feature.rb

@@ -0,0 +1,74 @@
+module Wackamole
+  class Feature
+  
+    def self.logs_cltn()     Wackamole::Control.collection( 'logs' ) ;  end  
+    def self.features_cltn() Wackamole::Control.collection( 'features' );  end  
+  
+    # Pagination size
+    def self.default_page_size() @page_size ||= 20; end
+  
+    # ---------------------------------------------------------------------------
+    # Find the app name and env for the features collection
+    # NOTE: Assumes 1 moled app per db...
+    def self.get_app_info
+      feature = features_cltn.find_one( {}, :fields => [:app, :env] )
+      raise "Unable to find a single feature in db `#{features_cltn.db.name}" unless feature 
+      { :app_name => feature['app'], :stage => feature['env'] }
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Paginate top features
+    def self.paginate_tops( conds, page=1, page_size=default_page_size )
+      tops = logs_cltn.group( [:fid], conds, { :count => 0 }, 'function(obj,prev) { prev.count += 1}', true )
+    
+      features = []
+      tops.sort{ |a,b| b['count'] <=> a['count'] }.each do |row|
+        features << { :fid => row['fid'], :total => row['count'].to_i }
+      end
+    
+      WillPaginate::Collection.create( page, page_size, features.size ) do |pager|      
+        offset = (page-1)*page_size
+        result = features[offset...(offset+page_size)]
+        result.each do |u|
+          feature = features_cltn.find_one( u[:fid] )
+          u[:name] = feature
+        end
+        pager.replace( result )
+      end
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Make sure indexes are setup for users
+    def self.ensure_indexes!
+      indexes       = features_cltn.index_information
+      created_count = 0
+
+      [:ctx].each do |name|
+        unless indexes.has_key?( "#{name}_1" )
+          features_cltn.create_index( name ) 
+          created_count += 1
+        end
+      end
+      unless indexes.has_key?( 'app_1_env_1' )
+        features_cltn.create_index( 
+          [ 
+            [:app, Mongo::ASCENDING], 
+            [:env, Mongo::ASCENDING] 
+          ]
+        )
+        created_count += 1
+      end      
+      unless indexes.has_key?( 'ctl_1_act_1' )
+        features_cltn.create_index( 
+          [ 
+            [:ctl, Mongo::ASCENDING], 
+            [:act, Mongo::ASCENDING] 
+          ],
+          true
+        )
+        created_count += 1
+      end
+      created_count
+    end
+  end
+end

data/lib/wackamole/models/log.rb

@@ -0,0 +1,45 @@
+require 'forwardable'
+
+module Wackamole
+  class Log
+    extend ::SingleForwardable
+  
+    def self.logs_cltn() Wackamole::Control.collection( 'logs' ); end
+  
+    def_delegators :logs_cltn, :find, :find_one
+    
+    # Pagination size
+    def self.default_page_size() @page_size ||= 20; end
+  
+    # ---------------------------------------------------------------------------
+    # Fetch all logs matching the given condition
+    def self.paginate( conds, page=1, page_size=default_page_size )
+      matching = logs_cltn.find( conds )    
+      WillPaginate::Collection.create( page, page_size, matching.count ) do |pager|
+        pager.replace( logs_cltn.find( conds, 
+          :sort  => [ ['did', 'desc'], ['tid', 'desc'] ],
+          :skip  => (page-1)*page_size, 
+          :limit => page_size ).to_a )
+      end      
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Makes sure the correct indexes are set
+    def self.ensure_indexes!
+      indexes       = logs_cltn.index_information
+      created_count = 0
+            
+      [:fid, :uid, :did, :tid].each do |name|
+        unless indexes.has_key?( "#{name}_1" )
+          logs_cltn.create_index( name )
+          created_count += 1
+        end
+      end
+      unless indexes.has_key?( 'did_-1_tid_-1' )
+        logs_cltn.create_index( [ [:did, Mongo::DESCENDING], [:tid, Mongo::DESCENDING] ] ) 
+        created_count += 1
+      end
+      created_count
+    end
+  end    
+end

data/lib/wackamole/models/mission.rb

@@ -0,0 +1,164 @@
+require 'forwardable'
+
+module Wackamole
+  class Mission
+    extend ::SingleForwardable
+
+    def self.rollups_cltn() @rollups ||= Wackamole::Control.collection( 'rollups', 'wackamole_mdb', :strict => false ); end  
+  
+    def_delegators :rollups_cltn, :find, :find_one
+  
+    # -------------------------------------------------------------------------
+    # Allows user to clear out perf or fault state til the next tick...  
+    def self.reset!( app, env, type )
+      rollups_cltn.update( { :app => app }, { '$set' => { "envs.#{env}.#{type}" => 0 } } )
+    end
+      
+    # -------------------------------------------------------------------------      
+    # Clean up rollups. Check if mole_db is still around
+    def self.clean_up!
+      databases   = Wackamole::Control.mole_databases
+      con         = Wackamole::Control.connection      
+      rollups     = rollups_cltn.find( {} )
+      delete_list = []
+      rollups.each do |rollup|
+        app       = rollup['app']
+        envs_info = rollup[envs].keys
+        envs_info.each do |env|
+          db_name = Wackamole::Control.to_mole_db( app, env )
+          delete_list << env unless databases.include?( db_name )
+        end
+        # if app is no longer around blow away the rollup
+        if delete_list.size == envs_info.size
+          rollups_cltn.remove( { :_id => rollup['_id'] } )
+        else
+          delete_list.each do |env| 
+            rollup[envs].delete( env )
+          end
+          rollups_cltn.save( rollup, :safe => true ) unless delete_list.empty?
+        end
+      end
+    end
+    
+    # -------------------------------------------------------------------------
+    # Retrieve reports if any...  
+    # BOZO !! Handle case where report is no longer valid - ie no mole db
+    def self.rollups( now, reset )
+      clean_up!
+      rollups = comb_applications( now, reset )
+      rollups.each_pair do |app_name, env_info|
+        env_info[envs].each_pair do |env, info|
+          info.each_pair do |mole_type, count|
+            rollup    = rollups_cltn.find_one( { :app => app_name } )
+            type_name = to_type_name( mole_type )
+            if rollup
+              rollup_info = rollup[envs]
+              if rollup_info and rollup_info[env]
+                (rollup_info[env][type_name] and !reset) ? rollup_info[env][type_name] += count : rollup_info[env][type_name] = count
+              elsif rollup_info
+                rollup_info[env] = { type_name => count }
+              # else
+              #   rollup_info[envs] = { env => { type_name => count } }
+              end
+              rollups_cltn.save( rollup, :safe => true )
+            else
+              row = { :app => app_name, envs => { env => { type_name => count } } }
+              rollups_cltn.insert( row, :safe => true )
+            end
+          end
+        end
+      end
+      find( {}, :sort => [ [:app, Mongo::ASCENDING], [:env, Mongo::ASCENDING] ] ).to_a
+    end
+  
+    # =========================================================================
+    private
+
+      # -----------------------------------------------------------------------
+      # Map rackamole types to report types  
+      def self.to_type_name( type )
+        case type
+          when Rackamole.perf
+            "perfs"
+          when Rackamole.fault
+            "faults"
+          when Rackamole.feature
+            "features"
+          else
+            raise "Invalid mole log type `#{type}"
+        end
+      end
+  
+      # ---------------------------------------------------------------------------
+      # Check moled apps status - reports any perf/excep that occurred since the 
+      # last check
+      def self.comb_applications( now, reset )     
+        report = {}
+        Wackamole::Control.mole_databases.each do |db_name|
+          db = Wackamole::Control.db( db_name )
+                         
+          app_name, env = Wackamole::Control.extract_app_info( db_name )        
+          totals        = analyse_logs( db, now, reset )
+        
+          if report[app_name]
+            report[app_name][envs][env] = totals
+          else
+            report[app_name] = { envs => { env => totals } }
+          end
+        end
+        report
+      end
+    
+      # -------------------------------------------------------------------------
+      # Report on possible application issues
+      def self.amend_report( report, app_name, env, log )
+        type = log['typ']
+        
+        if report[app_name]
+          env_info = report[app_name][envs]
+          if env_info[env]
+            env_info[env][type] ? env_info[env][type] += 1 : env_info[env][type] = 1
+          else
+            env_info[ env ] = { type => 1 }
+          end
+        else
+          report[app_name] = { envs => { env => { type => 1 } }  } 
+        end
+      end    
+
+      # -------------------------------------------------------------------------
+      # envs key
+      def self.envs() @envs ||= 'envs'; end
+        
+      # -------------------------------------------------------------------------        
+      # computes counts for each mole types
+      def self.analyse_logs( db, now, reset )
+        check_types = [Rackamole.perf, Rackamole.fault, Rackamole.feature]
+        date_id     = now.to_date_id.to_s
+        time_id     = now.to_time_id
+      
+        if reset
+          conds = {
+            :did => date_id,
+            :typ => { '$in'  => check_types }
+          }
+        else
+          conds = {
+            :did => { '$gte' => date_id },
+            :tid => { '$gte' => time_id },
+            :typ => { '$in'  => check_types }
+          }
+        end        
+
+        logs   = db['logs'].find( conds, :fields => ['typ', 'rti', 'fault', 'fid'] )          
+        totals = 
+        { 
+          Rackamole.feature  => 0, 
+          Rackamole.perf     => 0, 
+          Rackamole.fault    => 0 
+        }
+        logs.each { |log| totals[log['typ']] += 1 }
+        totals
+      end
+   end   
+end