mongo_rack 0.0.1

data/HISTORY

@@ -0,0 +1,2 @@
+o 0.0.1 / 2009-12-31
+  Initial drop

data/README.rdoc

@@ -0,0 +1,61 @@
+== mongo_rack
+
+   mongoDB based session management
+  
+== DESCRIPTION:
+
+  A mongoDB based rackable session store. Can be used with any rack based web frameworks.
+  
+== PROJECT INFORMATION
+
+* Developer:  Fernand Galiana
+* Git:        git://github.com/derailed/mongo-rack.git
+
+== REQUIREMENTS:
+
+* rack 1.0 or later
+* mongo + mongo_ext ruby adapter 0.18 or later
+
+== INSTALL:
+
+* sudo gem install mongo_rack
+  
+== USAGE:
+
+  use Rack::Session::Mongo, { :server => 'localhost:27017/mongo_ses/sessions }
+  
+  where server requires the following format
+  
+  {server_name_or_ip}:{port}/{database_name}/{collection_name}
+  
+  The server description by default will be localhost:2701/mongo_session/sessions
+  
+  Other options includes: 
+  
+  pool_size ( default is 1 ) 
+  pool_timeout ( defaults to 1 )
+    
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,31 @@
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+end
+
+ensure_in_path 'lib'
+require 'mongo_rack'
+
+task :default => 'spec:run'
+
+PROJ.name      = 'mongo_rack'
+PROJ.authors   = 'Fernand Galiana'
+PROJ.email     = 'fernand.galiana@gmail.com'
+PROJ.url       = 'http://github.com/derailed/mongo_rack'
+PROJ.summary   = "Rackable mongoDB based session management"
+PROJ.version   = "0.0.1"
+PROJ.ruby_opts = %w[-W0]
+PROJ.readme    = 'README.rdoc'
+PROJ.rcov.opts = ["--sort", "coverage", "-T"]
+PROJ.spec.opts << '--color'
+
+# Dependencies
+depend_on "rack"     , ">= 1.0.0"
+depend_on "mongo"    , ">= 0.18.1"
+depend_on "mongo_ext", ">= 0.18.1"

data/fred.rb

@@ -0,0 +1,26 @@
+# tnum = 10
+# r = Array.new(tnum) do
+#   Thread.new do
+#     puts "Making request"
+#     10
+#   end
+# end.reverse.map{|t| puts t.inspect;t.join; puts t.value }
+# 
+# r.each do |res|
+#   puts "Checking request #{res}"        
+# end
+
+
+a = Array.new( 10 ) do
+  Thread.new( 20 ) do |run| 
+    puts "Blee + #{run}"
+    20
+  end
+end
+
+puts a.inspect
+
+b = a.reverse.map{ |t| t.join.value }
+
+puts "Here"
+puts b.inspect

data/lib/core_ext/hash.rb

@@ -0,0 +1,6 @@
+require File.join( File.dirname(__FILE__), %w[.. mongo_rack session_hash] )
+
+# Reopen hash to add session access ie indifferent access to keys as symb or str
+class Hash
+  include MongoRack::SessionAccess
+end

data/lib/mongo_rack.rb

@@ -0,0 +1,159 @@
+require 'rack/session/abstract/id'
+require 'mongo'
+require File.join( File.dirname(__FILE__), %w[mongo_rack session_hash.rb] )
+
+module Rack  
+  module Session    
+    class Mongo < Abstract::ID      
+      attr_reader :mutex, :connection, :db, :sessions #:nodoc:
+      
+      # === Options for mongo_rack
+      # :server :: 
+      #   Specifies server, port, db and collection location. Defaults
+      #   to localhost:27017/mongo_session/sessions. Format must conform to
+      #   the format {host}:{port}/{database_name}/{collection_name}.
+      # :pool_size :: 
+      #   The connection socket pool size - see mongo-ruby-driver docs for settings.
+      #   Defaults to 1 connection.
+      # :pool_timeout :: 
+      #   The connection pool timeout. see mongo-ruby-driver docs for settings.
+      #   Defaults to 1 sec.
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
+        :server       => 'localhost:27017/mongo_session/sessions',
+        :pool_size    => 1,
+        :pool_timeout => 1.0
+
+      # Initializes mongo_rack. Pass in options for default override.
+      def initialize(app, options={})
+        super
+
+        host, port, db_name, cltn_name = parse_server_desc( @default_options[:server] )
+        
+        @mutex      = Mutex.new      
+        @connection = ::Mongo::Connection.new( host, port,
+          :pool_size => @default_options[:pool_size],
+          :timeout   => @default_options[:pool_timeout] )
+        @db         = @connection.db( db_name )
+        @sessions   = @db[cltn_name]
+      end
+                    
+      # Fetch session with optional session id. Retrieve session from mongodb if any    
+      def get_session( env, sid )
+        return _get_session( env, sid ) unless env['rack.multithread']
+        mutex.synchronize do
+          return _get_session( env, sid )
+        end        
+      end
+
+      # Update session params and sync to mongoDB.
+      def set_session( env, sid, new_session, options )
+        return _set_session( env, sid, new_session, options ) unless env['rack.multithread']
+        mutex.synchronize do    
+          return _set_session( env, sid, new_session, options )
+        end        
+      end
+                        
+      # =======================================================================
+      private
+
+        # Generates unique session id
+        def generate_sid
+          loop do          
+            sid = super
+            break sid unless sessions.find_one( { :_id => sid } )
+          end
+        end
+
+        # Check session expiration date
+        def fresh?( ses_obj )
+          return true if ses_obj['expire'] == 0
+          now = Time.now
+          ses_obj['expire'] >= now        
+        end
+      
+        # Clean out all expired sessions
+        def clean_expired!
+          sessions.remove( { :expire => { '$lt' => Time.now } } )
+        end
+
+        # parse server description string into host, port, db, cltn
+        def parse_server_desc( desc )
+          tokens = desc.split( "/" )
+          raise "Invalid server description" unless tokens.size == 3
+          server_desc = tokens[0].split( ":" )
+          raise "Invalid host:port description" unless server_desc.size == 2        
+          return server_desc.first, server_desc.last.to_i, tokens[1], tokens[2]
+        end
+
+        # fetch session with optional session id
+        def _get_session(env, sid)
+          if sid
+            ses_obj = sessions.find_one( { :_id => sid } )
+            session = MongoRack::SessionHash.new( ses_obj['data'] ) if ses_obj and fresh?( ses_obj )
+          end
+    
+          unless sid and session
+            env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
+            session = {}
+            sid     = generate_sid
+            ret     = sessions.save( { :_id => sid, :data => session } )
+            raise "Session collision on '#{sid.inspect}'" unless ret
+          end
+          session.instance_variable_set( '@old', MongoRack::SessionHash.new.merge(session) )
+          return [sid, session]        
+        rescue => boom
+          warn "#{self} is unable to find server."
+          warn $!.inspect
+          return [ nil, {} ]
+        end
+            
+        # update session information with new settings
+        def _set_session(env, sid, new_session, options)
+          ses_obj = sessions.find_one( { :_id => sid } )
+          if ses_obj
+            session = MongoRack::SessionHash.new( ses_obj['data'] )
+          else
+            session = MongoRack::SessionHash.new
+          end
+    
+          if options[:renew] or options[:drop]
+            sessions.remove( { :_id => sid } )
+            return false if options[:drop]
+            sid = generate_sid
+            sessions.insert( {:_id => sid, :data => {} } )
+          end
+          old_session = new_session.instance_variable_get('@old') || MongoRack::SessionHash.new
+          merged = merge_sessions( sid, old_session, new_session, session )
+
+          expiry = options[:expire_after]
+          expiry = expiry ? Time.now + options[:expire_after] : 0
+
+          # BOZO ! Use upserts here if minor changes ?
+          sessions.save( { :_id => sid, :data => merged, :expire => expiry } )
+          return sid
+        rescue => boom
+          warn "#{self} is unable to find server."
+          warn $!.inspect
+          return false
+        end
+
+        # merge old, new to current session state
+        def merge_sessions( sid, old_s, new_s, cur={} )
+          unless Hash === old_s and Hash === new_s
+            warn 'Bad old or new sessions provided.'
+            return cur
+          end
+                    
+          delete = old_s.keys - new_s.keys
+          warn "//@#{sid}: delete #{delete*','}" if $VERBOSE and not delete.empty?
+          delete.each{ |k| cur.delete(k) }
+
+          update = new_s.keys.select{ |k| new_s[k] != old_s[k] }
+          warn "//@#{sid}: update #{update*','}" if $VERBOSE and not update.empty?          
+          update.each{ |k| cur[k] = new_s[k] }
+          
+          cur
+        end
+    end
+  end
+end

data/lib/mongo_rack/session_hash.rb

@@ -0,0 +1,144 @@
+# Snagged HashWithIndifferentAccess for A/S
+module MongoRack
+  class SessionHash < Hash
+    
+    # Need to enable users to access session using either a symbol or a string as key
+    # This call wraps hash to provide this kind of access. No default allowed here. If a key
+    # is not found nil will be returned.
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super(constructor)
+        update(constructor)        
+        self.default = nil        
+      else
+        super(constructor)
+      end
+    end
+
+    # Checks for default value. If key does not exits returns default for hash
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = SessionHash.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    # 
+    #   hash_1 = SessionHash.new
+    #   hash_1[:key] = "value"
+    # 
+    #   hash_2 = SessionHash.new
+    #   hash_2[:key] = "New Value!"
+    # 
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    # 
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = SessionHash.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = SessionHash.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      SessionHash.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+    
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    #:nodoc:
+    def stringify_keys!; self end
+    #:nodoc:    
+    def symbolize_keys!; self end
+    #:nodoc:    
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge(self)
+    end
+
+    # =========================================================================
+    private
+
+      # converts key to string if symbol    
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      # check value and converts sub obj to session hash if any
+      def convert_value(value)
+        case value
+          when Hash
+            value.with_session_access
+          when Array
+            value.collect { |e| e.is_a?(Hash) ? e.with_session_access : e }
+          else
+            value
+        end
+      end
+  end
+end
+
+module MongoRack
+  module SessionAccess
+    def with_session_access
+      hash = MongoRack::SessionHash.new( self )
+      hash
+    end
+  end
+end

data/spec/mongo_rack_spec.rb

@@ -0,0 +1,207 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Rack::Session::Mongo do
+  before :all do
+    @session_key   = 'rack.session'
+    @session_match = /#{@session_key}=[0-9a-fA-F]+;/    
+    @db_name       = 'mongo_test'
+    @cltn_name     = 'sessions'
+    
+    @con      = Mongo::Connection.new
+    @db       = @con.db( @db_name )
+    @sessions = @db['sessions']
+    
+    @incrementor = lambda do |env|
+      env[@session_key]['counter'] ||= 0
+      env[@session_key]['counter']  += 1
+      Rack::Response.new( env[@session_key].inspect ).to_a
+    end    
+  end
+
+  it "should connect to a valid server" do
+    Rack::Session::Mongo.new( @incrementor, :server => "localhost:27017/#{@db_name}/#{@cltn_name}" )
+  end
+  
+  it "should fail if bad server specified" do
+    lambda do
+      Rack::Session::Mongo.new( @incrementor, :server => "blee:1111/#{@db_name}/#{@cltn_name}" )
+    end.should raise_error( Mongo::ConnectionFailure )
+  end
+
+  describe "cookies" do    
+    before :each do 
+      @pool = Rack::Session::Mongo.new( @incrementor, :server => "localhost:27017/#{@db_name}/#{@cltn_name}" ) 
+    end
+    
+    it "should create a new cookie correctly" do
+      res = Rack::MockRequest.new( @pool ).get( "/", 'rack.multithread' => false )
+      res['Set-Cookie'].should match( /^#{@session_key}=/ )
+      res.body.should == '{"counter"=>1}'
+      session_id = res['Set-Cookie'].match( /^#{@session_key}=(.*?);.*?/ )[1]
+      mongo_check( res, :counter, 1 )
+    end  
+  
+    it "should determine a session from a cookie" do
+      req    = Rack::MockRequest.new( @pool )
+      res    = req.get("/", 'rack.multithread' => false )
+      cookie = res["Set-Cookie"]
+      req.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false ).body.should == '{"counter"=>2}'
+      mongo_check( res, :counter, 2 )
+      req.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false ).body.should == '{"counter"=>3}'
+      mongo_check( res, :counter, 3 )    
+    end
+    
+    it "survives nonexistant cookies" do
+      bad_cookie = "rack.session=bumblebeetuna"
+      res = Rack::MockRequest.new( @pool ).get("/", "HTTP_COOKIE" => bad_cookie, 'rack.multithread' => false )
+      res.body.should == '{"counter"=>1}'
+      cookie = res["Set-Cookie"][@session_match]
+      cookie.should_not match( /#{bad_cookie}/ )
+    end
+    
+    it "maintains freshness" do
+      pool = Rack::Session::Mongo.new( @incrementor, :server => "localhost:27017/#{@db_name}/#{@cltn_name}", :expire_after => 1 )
+      res = Rack::MockRequest.new(pool).get('/', 'rack.multithread' => false )
+      res.body.should include('"counter"=>1')
+      cookie = res["Set-Cookie"]
+      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      res["Set-Cookie"].should == cookie
+      res.body.should include('"counter"=>2')
+      puts 'Sleeping to expire session' if $DEBUG
+      sleep 2
+      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      res["Set-Cookie"].should_not == cookie
+      res.body.should include( '"counter"=>1' )
+    end    
+    
+    it "deletes cookies with :drop option" do
+      drop_session = lambda do |env|
+        env['rack.session.options'][:drop] = true
+        @incrementor.call(env)
+      end
+            
+      req  = Rack::MockRequest.new(@pool)
+      drop = Rack::Utils::Context.new(@pool, drop_session)
+      dreq = Rack::MockRequest.new(drop)
+
+      res0 = req.get("/", 'rack.multithread' => false )
+      session = (cookie = res0["Set-Cookie"])[@session_match]
+      res0.body.should == '{"counter"=>1}'
+
+      res1 = req.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      res1["Set-Cookie"][@session_match].should == session
+      res1.body.should == '{"counter"=>2}'
+
+      res2 = dreq.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      res2["Set-Cookie"].should == nil
+      res2.body.should == '{"counter"=>3}'
+
+      res3 = req.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false)
+      res3["Set-Cookie"][@session_match].should_not == session
+      res3.body.should == '{"counter"=>1}'
+    end
+    
+    it "provides new session id with :renew option" do
+      renew_session = lambda do |env|
+        env['rack.session.options'][:renew] = true
+        @incrementor.call(env)
+      end
+      
+      req = Rack::MockRequest.new(@pool)
+      renew = Rack::Utils::Context.new(@pool, renew_session)
+      rreq = Rack::MockRequest.new(renew)
+
+      res0 = req.get("/", 'rack.multithread' => false )
+      session = (cookie = res0["Set-Cookie"])[@session_match]
+      res0.body.should == '{"counter"=>1}'
+
+      res1 = req.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      res1["Set-Cookie"][@session_match].should == session
+      res1.body.should == '{"counter"=>2}'
+
+      res2 = rreq.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      new_cookie = res2["Set-Cookie"]
+      new_session = new_cookie[@session_match]
+      new_session.should_not == session
+      res2.body.should == '{"counter"=>3}'
+
+      res3 = req.get("/", "HTTP_COOKIE" => new_cookie, 'rack.multithread' => false )
+      res3["Set-Cookie"][@session_match].should == new_session
+      res3.body.should == '{"counter"=>4}'
+    end
+    
+    it "omits cookie with :defer option" do
+      defer_session = lambda do |env|
+        env['rack.session.options'][:defer] = true
+        @incrementor.call(env)
+      end
+      
+      req   = Rack::MockRequest.new(@pool)
+      defer = Rack::Utils::Context.new(@pool, defer_session)
+      dreq  = Rack::MockRequest.new(defer)
+
+      res0 = req.get("/", 'rack.multithread' => false )
+      session = (cookie = res0["Set-Cookie"])[@session_match]
+      res0.body.should == '{"counter"=>1}'
+
+      res1 = req.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      res1["Set-Cookie"][@session_match].should == session
+      res1.body.should == '{"counter"=>2}'
+
+      res2 = dreq.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      res2["Set-Cookie"].should == nil
+      res2.body.should == '{"counter"=>3}'
+
+      res3 = req.get("/", "HTTP_COOKIE" => cookie, 'rack.multithread' => false )
+      res3["Set-Cookie"][@session_match].should == session
+      res3.body.should == '{"counter"=>4}'
+    end
+    
+    it "multithread: should cleanly merge sessions" do
+      @pool = Rack::Session::Mongo.new( @incrementor, :server => "localhost:27017/#{@db_name}/#{@cltn_name}", :pool_size => 10 ) 
+
+      req = Rack::MockRequest.new( @pool )
+
+      res             = req.get('/')
+      res.body.should == '{"counter"=>1}'
+      cookie          = res["Set-Cookie"]
+      sess_id         = cookie[/#{@pool.key}=([^,;]+)/,1]
+
+      r = Array.new( 10 ) do 
+        Thread.new( req ) do |run|
+          req.get( "/", "HTTP_COOKIE" => cookie, 'rack.multithread' => true )
+        end
+      end.reverse.map{ |t| t.join.value }
+
+      r.each do |res|
+        res['Set-Cookie'].should == cookie
+        res.body.should include( '"counter"=>2' )
+      end
+      
+      drop_counter = proc do |env|
+        env['rack.session'].delete 'counter'
+        env['rack.session']['foo'] = 'bar'
+        [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+      end
+      tses = Rack::Utils::Context.new @pool, drop_counter
+      treq = Rack::MockRequest.new( tses )
+      
+      tnum = 10
+      r = Array.new(tnum) do
+        Thread.new(treq) do |run|
+          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        end
+      end.reverse.map{|t| t.join.value }
+      r.each do |res|
+        res['Set-Cookie'].should == cookie
+        res.body.should include('"foo"=>"bar"')
+      end
+      
+      session = @pool.sessions.find_one( {:_id => sess_id } )
+      session['data'].size.should == 1
+      session['data']['counter'].should be_nil
+      session['data']['foo'].should == 'bar'      
+    end
+    
+  end
+end