mongo3 0.0.1 → 0.0.2

data/README.rdoc

@@ -29,11 +29,16 @@
 
 == ROAD MAP:
 
-* Provide support for db authentication
-* Ability to drilldown in collections and query for content
+* Provide support for db authentication [done]
+* Ability to drilldown in collections and query for content [done]
 * CRUD on dbs, collections, indexes, users
 * Support for managing shards and replication
 
+== DEPENDENCIES
+
+* mongo + mongo_ext
+* agnostic-will_paginate
+
 == INSTALL:
   
   sudo gem install mongo3
@@ -53,8 +58,10 @@
       port: 27017
     
     beta:
-      host: beta_host_name
-      port: 27017
+      host:     beta_host_name
+      port:     27017
+      user:     bobo
+      password: secret
     
 === Launch It!
 

data/Rakefile

@@ -29,3 +29,9 @@ PROJ.rcov.opts   = ["--sort", "coverage", "-T"]
 PROJ.ignore_file = "*.log"
 PROJ.spec.opts   << '--color'
 PROJ.rdoc.include = %w[.rb]
+
+# Dependencies
+depend_on "mongo"                 , ">= 0.18.1"
+depend_on "mongo_ext"             , ">= 0.18.1"
+depend_on "agnostic-will_paginate", ">= 3.0.0"
+

data/config/mongo3.yml

@@ -1,12 +1,12 @@
 development:
-  :host: localhost
-  :port: 27017
+  host: localhost
+  port: 27017
   
 beta:
-  :host:     dev8
-  :port:     27018
-  :user:     "blee"
-  :password: "fred"
+  host:     dev8
+  port:     27018
+  user:     "blee"
+  password: "fred"
       
 # production:
 #   :host:     dev8

data/lib/controllers/collections.rb

@@ -1,7 +1,58 @@
+require 'json'
+
 module Collections
   
-  get "/cltns" do
-    puts "Cltns"
+  # --------------------------------------------------------------------------- 
+  # Paginate on a collection
+  get "/cltn/:page" do
+    @back_url  = "/explore/back"
+    @page      = params[:page].to_i || 1
+    @title     = title_for( session[:path_names] )
+    
+    load_cltn( params[:page].to_i )
+    erb :cltn_list
+  end  
+  
+  # ---------------------------------------------------------------------------
+  post "/cltn_refresh/:page" do
+    selected_cols = params[:cols].keys.sort    
+    session[:selected_cols] = selected_cols
+
+    load_cltn( params[:page].to_i )
+        
+    erb :cltn_update_js, :layout => false
   end
   
+  # ---------------------------------------------------------------------------
+  # BOZO !! Validation....
+  post "/cltn_search" do
+    json = params[:search].gsub( /'/, "\"" )    
+    if json.empty?
+      @query = {}
+      @sort  = {}
+    else
+      tokens = json.split( "|" )      
+      @query = JSON.parse( tokens.shift )
+      @sort  = tokens.empty? ? [] : JSON.parse( tokens.first )    
+    end
+    session[:query_params] = [@query, @sort]
+    
+    load_cltn
+    erb :cltn_update_js, :layout => false
+  end
+
+  # ===========================================================================
+  helpers do    
+    def load_cltn( page=1 )
+      query_params   = session[:query_params] || [{},[]]
+      @query         = [query_params.first.to_json, query_params.last.to_json].join(",")
+      @page          = page
+      path_names     = session[:path_names]
+      path_ids       = session[:path_ids]
+      
+      @cltn          = options.connection.paginate_cltn( path_names, query_params, @page, 15 )
+      @cols          = @cltn.first.keys.sort
+      @selected_cols = session[:selected_cols] || @cols[0...5]
+    end
+  end
 end

data/lib/controllers/databases.rb

@@ -1,7 +1,16 @@
 module Databases
   
-  get "/dbs" do
-    puts "Dbs"
-  end
+  # ---------------------------------------------------------------------------  
+  get "/db/:page" do
+    page       = params[:page].to_i || 1
+    path_ids   = session[:path_ids]
+    path_names = session[:path_names]
+          
+    @cltns     = options.connection.paginate_db( path_names, page, 10 )
+    @title     = title_for( path_names )    
+    @back_url  = "/explore/back"
+    
+    erb :db_list
+  end  
   
 end

data/lib/controllers/explore.rb

@@ -4,27 +4,56 @@ module Explore
   get '/explore' do
     reset_crumbs!
     @root = options.connection.build_tree
+Mongo3::Node.dump( @root )
     erb :explore
   end
 
   # -----------------------------------------------------------------------------
-  get '/explore/show/:path/:crumbs' do
-    path   = params[:path]
-    crumbs = params[:crumbs]
+  get '/explore/back' do  
+    session[:selected_cols] = nil
+    session[:query_params]  = nil
+ 
+    back_paths!
+    path_ids   = session[:path_ids]
+    path_names = session[:path_names]
     
-    @info = options.connection.show( path, crumbs )
+    reset_crumbs!
+    crumbs_from_path( path_ids, path_names )
+    
+    @root = options.connection.build_partial_tree( path_ids, path_names )
+# Mongo3::Node.dump( @root )
+    
+    # need to adjust crumbs in case something got blown...
+    @center = path_ids.split( "|" ).last
+     
+    erb :explore
+  end
+  
+  # -----------------------------------------------------------------------------
+  get '/explore/show/:path_ids/:path_names' do
+    path_ids   = params[:path_ids]
+    path_names = params[:path_names]
+    
+    @info = options.connection.show( path_names )
+        
+    session[:path_ids]   = path_ids
+    session[:path_names] = path_names
     
     partial :info
   end
   
   # -----------------------------------------------------------------------------
-  get '/explore/more_data/:path/:crumbs/*' do
-    path     = params[:path]
-    crumbs   = params[:crumbs]
+  get '/explore/more_data/:path_ids/:path_names/*' do
+    path_ids   = params[:path_ids]
+    path_names = params[:path_names]
+
+    session[:path_ids]   = path_ids
+    session[:path_names] = path_names
     
-    crumbs_from_path( path, crumbs )    
+    crumbs_from_path( path_ids, path_names )    
     
-    @sub_tree = options.connection.build_sub_tree( path, crumbs )
+    @sub_tree = options.connection.build_sub_tree( path_ids, path_names )
+# Mongo3::Node.dump_adj( @sub_tree )
     @node_id  = @sub_tree.first[:id]
     
     erb :more_data_js, :layout => false
@@ -38,8 +67,10 @@ module Explore
   
   # -----------------------------------------------------------------------------  
   get '/explore/center/:node_id' do
-    @node_id = params[:node_id]    
+    @node_id = params[:node_id]  
+      
     pop_crumb!( @node_id )
+    
     erb :center_js, :layout => false
   end
       

data/lib/helpers/collection_helper.rb

@@ -0,0 +1,19 @@
+require 'will_paginate/view_helpers/base'
+require 'will_paginate/view_helpers/link_renderer'
+
+module WillPaginate::ViewHelpers
+  class LinkRenderer
+    def url( page )
+      "#{@options[:params][:url]}/#{page}"
+    end
+  end
+end
+
+
+module CollectionHelper
+
+ helpers do
+   include WillPaginate::ViewHelpers::Base   
+  end
+  
+end

data/lib/helpers/crumb_helper.rb

@@ -1,23 +1,23 @@
 module CrumbHelper
   
   helpers do    
-    def crumbs_from_path( path, crumbs )
-      crumb_tokens  = crumbs.split( "|" )
-      path_tokens   = path.split( "|" )
+    def crumbs_from_path( path_ids, path_names )
+      path_id_tokens   = path_ids.split( "|" )      
+      path_name_tokens = path_names.split( "|" )
       
       @crumbs = []
       count   = 0
-      crumb_tokens.each do |crumb|
-        @crumbs << [crumb, "/explore/center/#{path_tokens[count]}"]
+      path_name_tokens.each do |crumb|
+        @crumbs << [crumb, "/explore/center/#{path_id_tokens[count]}"]
         count += 1
       end
       session[:crumbs] = @crumbs
     end
     
     def pop_crumb!( node_id )
+      path  = "/explore/center/#{node_id}"
       level = 0
       range = nil
-      path  = "/explore/center/#{node_id}"
       @crumbs.each do |pair|
         if pair.last == path
           range = level
@@ -36,7 +36,7 @@ module CrumbHelper
   
     def add_crumb( title, url )
       titles = @crumbs.map{ |p| p.first }
-      unless titles.include?( title )        
+      unless titles.include?( title )
         @crumbs.pop if @crumbs.size == 3
         @crumbs << [title, url]
         session[:crumbs] = @crumbs

data/lib/helpers/main_helper.rb

@@ -13,6 +13,29 @@ module MainHelper
   
  helpers do   
    
+    def back_paths!
+      path_ids   = session[:path_ids]
+      path_names = session[:path_names]
+      new_path_ids = path_ids.split( "|" )
+      new_path_ids.pop
+      session[:path_ids] = new_path_ids.join( "|" )
+    
+      new_path_names = path_names.split( "|" )
+      new_path_names.pop
+      session[:path_names] = new_path_names.join( "|" )
+    end
+    
+    def title_for( path_names )
+      tokens = path_names.split( "|" )
+      buff = case tokens.length 
+        when 2 : "Environment"
+        when 3 : "Database"
+        else     "Collection"
+      end
+      
+      buff += " <em>#{tokens.last}</em>"
+    end
+    
     def display_info( info )
       return info if info.is_a?( String )
       if info.is_a?( Hash )

data/lib/main.rb

@@ -3,6 +3,8 @@ require 'sinatra'
 require 'forwardable'
 require File.join( File.dirname(__FILE__), 'mongo3.rb' )
 require 'mongo'
+gem 'agnostic-will_paginate'
+require 'will_paginate'
 
 set :public, File.join( File.dirname(__FILE__), %w[public] )
 set :views , File.join( File.dirname(__FILE__), %w[views] )
@@ -21,9 +23,9 @@ end
 # Before filters
 before do
   unless request.path =~ /\.[css gif png js]/
-    @crumbs = session[:crumbs] 
+    @crumbs = session[:crumbs]
     unless @crumbs
-      @crumbs = [ ['HOME', '/center'] ]
+      @crumbs = [ ['home', '/explore/center/home'] ]
       session[:crumbs] = @crumbs
     end
   end

data/lib/mongo3/connection.rb

@@ -4,25 +4,14 @@ module Mongo3
     def initialize( config_file )
       @config_file = config_file
     end
-        
-    # Connects to mongo given an environment
-    # BOZO !! Auth... 
-    # TODO - Need to close out connection via block
-    def connect_for( env, &block )
-      info = landscape[env]
-      puts ">>> Connecting for #{env} -- #{info[:host]}-#{info[:port]}"
-      con = Mongo::Connection.new( info[:host], info[:port] )
-      yield con
-      con.close()
-    end
-    
-    def show( path, crumbs )
-      path_tokens  = path.split( "|" )
-      crumb_tokens = crumbs.split( "|" )
-      info         = OrderedHash.new
-      env          = path_tokens[1]
+            
+    def show( path_names )
+      path_name_tokens = path_names.split( "|" )
+      info             = OrderedHash.new
+      env              = path_name_tokens[1]
       
-      if path_tokens.size == 2
+      info[:title] = path_name_tokens.last
+      if path_name_tokens.size == 2
         connect_for( env ) do |con|
           info[:name]        = env
           info[:host]        = con.host
@@ -31,62 +20,89 @@ module Mongo3
           con.database_info.sort { |a,b| b[1] <=> a[1] }.each { |e| info[:databases][e[0]] = to_mb( e[1] ) }
           info[:server] = con.server_info
         end
-      elsif path_tokens.size == 3
-        db_name = crumb_tokens.pop
-        connect_for( env ) do |con|
+      elsif path_name_tokens.size == 3
+        db_name = path_name_tokens.pop
+        connect_for( env ) do |con|          
           db = con.db( db_name )
-          info[:size] = to_mb( con.database_info[db_name] )
-          info[:node] = db.nodes
+          info[:edit]        = "/db/1"
+          info[:size]        = to_mb( con.database_info[db_name] )
+          info[:node]        = db.nodes
           info[:collections] = db.collection_names.size
           info[:error]       = db.error
           info[:last_status] = db.last_status
         end
-      elsif path_tokens.size == 4
-        cltn_name = crumb_tokens.pop
-        db_name   = crumb_tokens.pop
+      elsif path_name_tokens.size == 4
+        cltn_name = path_name_tokens.pop
+        db_name   = path_name_tokens.pop
         connect_for( env ) do |con|
-          db = con.db( db_name )
-          cltn = db[cltn_name]
-          info[:size] = cltn.count
+          db      = con.db( db_name )
+          cltn    = db[cltn_name]
+          indexes = db.index_information( cltn_name )
           
-          indexes = db.index_information( cltn_name )          
-          info[:indexes] = format_indexes( db.index_information( cltn_name ) ) if indexes and !indexes.empty?
+          info[:edit]    = "/cltn/1"
+          info[:size]    = cltn.count
+          info[:indexes] = format_indexes( indexes ) if indexes and !indexes.empty?
         end
-      end
-      
+      end      
       info
     end
+
+    def paginate_db( path_names, page=1, per_page=10 )
+      path_name_tokens = path_names.split( "|" )
+      env              = path_name_tokens[1]
+      list             = nil
+      connect_for( env ) do |con|
+        db_name = path_name_tokens.pop
+        db      = con.db( db_name )
+        cltn    = db.collection_names.sort
         
-    def format_indexes( indexes )
-      formatted = {}
-      indexes.each_pair do |key, values|
-        buff = []
-        values.each do |pair|
-          buff << "#{pair.first} [#{pair.last}]"
-        end
-        formatted[key] = buff
-      end  
-      formatted    
+        list = WillPaginate::Collection.create( page, per_page, cltn.size ) do |pager|
+          offset = (page-1)*per_page
+          names = cltn[offset..(offset+per_page)]
+          cltns = []
+          names.each do |name|
+            list = db[name]
+            row  = OrderedHash.new
+            row[:name]  = name
+            row[:count] = list.count
+            cltns << row
+          end          
+          pager.replace( cltns ) 
+        end        
+      end
+      list
     end
-    
+        
+    def paginate_cltn( path_names, query_params=[{},[]], page=1, per_page=10 )
+      path_name_tokens = path_names.split( "|" )
+      env              = path_name_tokens[1]
+      list             = nil
+      connect_for( env ) do |con|
+        cltn_name = path_name_tokens.pop
+        db_name   = path_name_tokens.pop
+        db        = con.db( db_name )
+        cltn      = db[cltn_name]
+        
+        list = WillPaginate::Collection.create( page, per_page, cltn.count ) do |pager|
+          offset = (page-1)*per_page
+          sort   = query_params.last.empty? ? [ ['_id', Mongo::DESCENDING] ] : query_params.last
+          pager.replace( cltn.find( query_params.first, 
+            :sort  => sort,
+            :skip  => offset, 
+            :limit => per_page ).to_a)
+        end        
+      end
+      list
+    end
+            
     # Fetch the environment landscape from the config file
     def landscape
       config
     end
 
-    # db request occurs within dist 2
-    def db_request?( path )
-      path.size == 2
-    end
-    
-    # cltn request occurs within dist 3
-    def cltn_request?( path )
-      path.size == 3
-    end
-
     # Build environment tree
     def build_tree
-      root = Node.new( "home", "home", :path => 'home', :crumbs => 'home' )
+      root = Node.make_node( "home" )
       
       # iterate thru envs
       id = 1
@@ -97,39 +113,77 @@ module Mongo3
       end
       root
     end
+
+    # Build environment tree
+    def build_partial_tree( path_ids, path_names )
+      path_id_tokens   = path_ids.split( "|" )
+      path_name_tokens = path_names.split( "|" )      
+      bm_env           = path_name_tokens[1]
+      bm_cltn          = path_name_tokens.pop if path_name_tokens.size == 4
+      bm_db            = path_name_tokens.pop if path_name_tokens.size == 3
+      
+      root = Node.make_node( "home" )
+      
+      # iterate thru envs
+      config.each_pair do |env, info|
+        node = Node.new( env, env, :dyna => true )
+        root << node
+        if node.name == bm_env
+          connect_for( env ) do |con|      
+            count = 0
+            data  = { :dyna => true }
+            con.database_names.each do |db_name|
+              db      = con.db( db_name, :strict => true )
+              cltns   = db.collection_names.size  
+              db_node = Node.new( "#{env}_#{count}", "#{db_name}(#{cltns})", data.clone )
+              node << db_node
+              count += 1
+              if bm_db and db_node.name =~ /^#{bm_db}/
+                cltn_count = 0
+                data = { :dyna => false }
+                db.collection_names.each do |cltn_name|
+                  size = db[cltn_name].count
+                  cltn_node = Node.new( "#{db_name}_#{cltn_count}", "#{cltn_name}(#{size})", data.clone )
+                  db_node << cltn_node
+                  cltn_count += 1
+                end              
+              end
+            end
+          end
+        end
+      end
+      root
+    end
     
     # Build an appropriate subtree based on requested item
-    def build_sub_tree( path, crumbs )
-      path_tokens  = path.split( "|" )
-      crumb_tokens = crumbs.split( "|" )
-      parent_id    = path_tokens.last
-      db_name      = crumb_tokens.last
-      
-      if db_request?( path_tokens )
-        sub_tree = build_db_tree( parent_id, db_name )
+    def build_sub_tree( path_ids, path_names )
+      path_id_tokens   = path_ids.split( "|" )
+      path_name_tokens = path_names.split( "|" )
+      env              = path_name_tokens[1]      
+      parent_id        = path_id_tokens.last
+            
+      if db_request?( path_name_tokens )
+        sub_tree = build_db_tree( parent_id, env )
       else
-        env = crumb_tokens[1]
+        db_name  = path_name_tokens.last        
         sub_tree = build_cltn_tree( parent_id, env, db_name )
       end
       sub_tree.to_adjacencies
     end
-    
-    
+        
     # Connects to host and spews out all available dbs
     # BOZO !! Need to deal with Auth?
-    def build_db_tree( parent_id, env )
+    def build_db_tree( parent_id, env )    
       sub_root = nil
       connect_for( env ) do |con|      
-        root = Node.new( "home", "home" )
+        root = Node.make_node( "home" )
         sub_root = Node.new( parent_id, env )
       
         root << sub_root
       
         count = 0
         data  = { :dyna => true }
-        # excludes = %w[admin local]
         con.database_names.each do |db_name|
-          # next if excludes.include?( db_name )
           db    = con.db( db_name, :strict => true )
           cltns = db.collection_names.size  
           node  = Node.new( "#{env}_#{count}", "#{db_name}(#{cltns})", data.clone )
@@ -145,17 +199,15 @@ module Mongo3
       sub_root = nil
       connect_for( env ) do |con|
         db        = con.db( db_name )      
-        root      = Node.new( "home", "home" )
-        env_node  = Node.new( env, env )
+        root      = Node.make_node( "home" )
+        env_node  = Node.make_node( env )
         sub_root  = Node.new( parent_id, db_name )
         root     << env_node
         env_node << sub_root
       
         count = 0
-        # excludes = %w[system.indexes]
         data = { :dyna => false }
         db.collection_names.each do |cltn_name|
-          # next if excludes.include?( cltn_name )
           size = db[cltn_name].count
           node = Node.new( "#{db_name}_#{count}", "#{cltn_name}(#{size})", data.clone )
           sub_root << node
@@ -164,9 +216,46 @@ module Mongo3
       end
       sub_root
     end
-    
+        
     # =========================================================================
     private
+
+      # Connects to mongo given an environment
+      # BOZO !! Auth... 
+      def connect_for( env, &block )
+        info = landscape[env]
+        puts ">>> Connecting for #{env} -- #{info['host']}-#{info['port']}"
+        con = Mongo::Connection.new( info['host'], info['port'] )
+        
+        if info['user'] and info['password']
+          con.db( 'admin' ).authenticate( info['user'], info['password'] )
+        end
+        yield con
+        con.close()
+      end
+
+      # db request occurs within dist 2
+      def db_request?( path )
+        path.size == 2
+      end
+    
+      # cltn request occurs within dist 3
+      def cltn_request?( path )
+        path.size == 3
+      end
+
+      # Break down indexes in index + asc/desc   
+      def format_indexes( indexes )
+        formatted = {}
+        indexes.each_pair do |key, values|
+          buff = []
+          values.each do |pair|
+            buff << "#{pair.first} [#{pair.last}]"
+          end
+          formatted[key] = buff
+        end  
+        formatted    
+      end
    
       # Convert size to mb
       def to_mb( val )

data/lib/mongo3/node.rb

@@ -12,6 +12,10 @@ module Mongo3
       @parent   = nil
     end
     
+    def self.make_node( name )
+      Node.new( name, name, :path_ids => name, :path_names => name )
+    end
+    
     # Add a child node
     def <<( new_one )
       new_one.parent = self
@@ -20,8 +24,8 @@ module Mongo3
     end
 
     def update_paths( node )
-      node.data[:crumbs] = node.path( :name )
-      node.data[:path]   = node.path
+      node.data[:path_names] = node.path( :name )
+      node.data[:path_ids]   = node.path( :oid )
       node.children.each do |child|
         child.update_paths( child )
       end

data/lib/mongo3.rb

@@ -2,7 +2,7 @@
 module Mongo3
 
   # :stopdoc:
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc: