merb-core 0.9.5 → 0.9.6

data/lib/merb-core/dispatch/session/memcached.rb

@@ -1,184 +1,48 @@
 module Merb
 
-  module SessionMixin
-
-    # Adds a before and after dispatch hook for setting up the memcached
-    # session store.
-    #
-    # ==== Parameters
-    # base<Class>:: The class to which the SessionMixin is mixed into.
-    def setup_session
-      orig_key = cookies[_session_id_key]
-      session, key = Merb::MemCacheSession.persist(orig_key)
-      request.session = session
-      @_fingerprint = Marshal.dump(request.session.data).hash
-      if key != orig_key 
-        set_session_id_cookie(key)
-      end
-    end
-
-    # Finalizes the session by storing the session ID in a cookie, if the
-    # session has changed.
-    def finalize_session
-      if @_fingerprint != Marshal.dump(request.session.data).hash
-        begin
-          CACHE.set("session:#{request.session.session_id}", request.session.data)
-        rescue => err
-          Merb.logger.debug("MemCache Error: #{err.message}")
-          Merb::SessionMixin::finalize_session_exception_callbacks.each {|x| x.call(err) }
-        end
-      end
-      if request.session.needs_new_cookie or @_new_cookie
-        set_session_id_cookie(request.session.session_id)
-      end
-    end
-
-    # ==== Returns
-    # String:: The session store type, i.e. "memcache".
-    def session_store_type
-      "memcache"
-    end
-  end
-
-  ##
   # Sessions stored in memcached.
   #
   # Requires setup in your +init.rb+.
   #
-  #   require 'memcache'
-  #   CACHE = MemCache.new('127.0.0.1:11211', { :namespace => 'my_app' })
-  #
-  # And a setting in +init.rb+:
-  #
-  #   c[:session_store] = 'memcache'
-  #
-  # If you are using the memcached gem instead of memcache-client, you must setup like this:
-  #
-  #   require 'memcached'
-  #   CACHE = Memcached.new('127.0.0.1:11211', { :namespace => 'my_app' })
-  #
-  class MemCacheSession
-
-    attr_accessor :session_id
-    attr_accessor :data
-    attr_accessor :needs_new_cookie
-
-    # ==== Parameters
-    # session_id<String>:: A unique identifier for this session.
-    def initialize(session_id)
-      @session_id = session_id
-      @data = {}
-    end
-
-    class << self
-
-      # Generates a new session ID and creates a new session.
-      #
-      # ==== Returns
-      # MemCacheSession:: The new session.
-      def generate
-        sid = Merb::SessionMixin::rand_uuid
-        new(sid)
-      end
-
-      # ==== Parameters
-      # session_id<String:: The ID of the session to retrieve.
-      #
-      # ==== Returns
-      # Array::
-      #   A pair consisting of a MemCacheSession and the session's ID. If no
-      #   sessions matched session_id, a new MemCacheSession will be generated.
-      #
-      # ==== Notes
-      # If there are persiste exceptions callbacks to execute, they all get executed
-      # when Memcache library raises an exception.
-      def persist(session_id)
-        unless session_id.blank?
-          begin
-            session = CACHE.get("session:#{session_id}")
-          rescue => err
-            Merb.logger.warn!("Could not persist session to MemCache: #{err.message}")
-            Merb::SessionMixin::persist_exception_callbacks.each {|x| x.call(err) }
-          end
-          if session.nil?
-            # Not in memcached, but assume that cookie exists
-            session = new(session_id)
-          end
-        else
-          # No cookie...make a new session_id
-          session = generate
-        end
-        if session.is_a?(MemCacheSession)
-          [session, session.session_id]
-        else
-          # recreate using the rails session as the data
-          session_object = MemCacheSession.new(session_id)
-          session_object.data = session
-          [session_object, session_object.session_id]
-        end
-      end
-
-      # Don't try to reload in dev mode.
-      def reloadable?
-        false
-      end
-
-    end
-
-    # Regenerate the session ID.
-    def regenerate
-      @session_id = Merb::SessionMixin::rand_uuid
-      self.needs_new_cookie=true
-    end
-
-    # Recreates the cookie with the default expiration time. Useful during log
-    # in for pushing back the expiration date.
-    def refresh_expiration
-      self.needs_new_cookie=true
-    end
-
-    # Deletes the session by emptying stored data.
-    def delete
-      @data = {}
-    end
-
-    # ==== Returns
-    # Boolean:: True if session has been loaded already.
-    def loaded?
-      !! @data
-    end
-
-    # ==== Parameters
-    # k<~to_s>:: The key of the session parameter to set.
-    # v<~to_s>:: The value of the session parameter to set.
-    def []=(k, v)
-      @data[k] = v
-    end
-
-    # ==== Parameters
-    # k<~to_s>:: The key of the session parameter to retrieve.
-    #
-    # ==== Returns
-    # String:: The value of the session parameter.
-    def [](k)
-      @data[k]
-    end
-
-    # Yields the session data to an each block.
-    #
-    # ==== Parameter
-    # &b:: The block to pass to each.
-    def each(&b)
-      @data.each(&b)
-    end
-
-    private
+  #   Merb::BootLoader.after_app_loads do
+  #     require 'memcached'
+  #     Merb::MemcacheSession.store = 
+  #        Memcached.new('127.0.0.1:11211', { :namespace => 'my_app' })
+  #   end
+  
+  class MemcacheSession < SessionStoreContainer
+    
+    # The session store type
+    self.session_store_type = :memcache
+    
+  end
 
-    # Attempts to redirect any messages to the data object.
-    def method_missing(name, *args, &block)
-      @data.send(name, *args, &block)
-    end
+end
 
+class Memcached
+  
+  # Make the Memcached gem conform to the SessionStoreContainer interface
+  
+  # ==== Parameters
+  # session_id<String>:: ID of the session to retrieve.
+  #
+  # ==== Returns
+  # ContainerSession:: The session corresponding to the ID.
+  def retrieve_session(session_id)
+    get("session:#{session_id}")
   end
-
+  
+  # ==== Parameters
+  # session_id<String>:: ID of the session to set.
+  # data<ContainerSession>:: The session to set.
+  def store_session(session_id, data)
+    set("session:#{session_id}", data)
+  end
+  
+  # ==== Parameters
+  # session_id<String>:: ID of the session to delete.
+  def delete_session(session_id)
+    delete("session:#{session_id}")
+  end
+  
 end

data/lib/merb-core/dispatch/session/memory.rb

@@ -1,37 +1,5 @@
 module Merb
-
-  module SessionMixin
-
-    # Adds a before and after dispatch hook for setting up the memory session
-    # store.
-    #
-    # ==== Parameters
-    # base<Class>:: The class to which the SessionMixin is mixed into.
-    def setup_session
-      orig_key = cookies[_session_id_key]
-      session, key = Merb::MemorySession.persist(orig_key)
-      request.session = session
-      if key != orig_key 
-        set_session_id_cookie(key)
-      end
-    end
-
-    # Finalizes the session by storing the session ID in a cookie, if the
-    # session has changed.
-    def finalize_session
-      if request.session.needs_new_cookie or @_new_cookie
-        set_session_id_cookie(request.session.session_id)
-      end
-    end
-
-    # ==== Returns
-    # String:: The session store type, i.e. "memory".
-    def session_store_type
-      "memory"
-    end
-  end
   
-  ##
   # Sessions stored in memory.
   #
   # Set it up by adding the following to your init file:
@@ -43,199 +11,85 @@ module Merb
   #
   # Sessions will remain in memory until the server is stopped or the time
   # as set in :memory_session_ttl expires.
-  class MemorySession
-
-    attr_accessor :session_id
-    attr_accessor :data
-    attr_accessor :needs_new_cookie
-
-    # ==== Parameters
-    # session_id<String>:: A unique identifier for this session.
-    def initialize(session_id)
-      @session_id = session_id
-      @data = {}
-    end
-
-    class << self
-
-      # Generates a new session ID and creates a new session.
-      #
-      # ==== Returns
-      # MemorySession:: The new session.
-      def generate
-        sid = Merb::SessionMixin::rand_uuid
-        MemorySessionContainer[sid] = new(sid)
-      end
-
-      # ==== Parameters
-      # session_id<String:: The ID of the session to retrieve.
-      #
-      # ==== Returns
-      # Array::
-      #   A pair consisting of a MemorySession and the session's ID. If no
-      #   sessions matched session_id, a new MemorySession will be generated.
-      def persist(session_id)
-        if session_id
-          session = MemorySessionContainer[session_id]
-        end
-        unless session
-          session = generate
-        end
-        [session, session.session_id]
-      end
-
-    end
-
-    # Regenerate the Session ID
-    def regenerate
-      new_sid = Merb::SessionMixin::rand_uuid 
-      old_sid = @session_id
-      MemorySessionContainer[new_sid] = MemorySessionContainer[old_sid]
-      @session_id = new_sid
-      MemorySessionContainer.delete(old_sid)
-      self.needs_new_cookie=true 
-    end 
-      
-    # Recreates the cookie with the default expiration time. Useful during log
-    # in for pushing back the expiration date.
-    def refresh_expiration 
-      self.needs_new_cookie=true 
-    end 
+  class MemorySession < SessionStoreContainer
     
-    # Deletes the session by emptying stored data.
-    def delete
-      @data = {}
+    # The session store type
+    self.session_store_type = :memory
+    
+    # Bypass normal implicit class attribute reader - see below.
+    def store
+      self.class.store
     end
-     
-    # ==== Returns
-    # Boolean:: True if session has been loaded already.
-    def loaded?
-      !! @data
+    
+    # Lazy load/setup of MemorySessionStore.
+    def self.store
+      @_store ||= MemorySessionStore.new(Merb::Config[:memory_session_ttl])
     end
     
+  end
+  
+  # Used for handling multiple sessions stored in memory.
+  class MemorySessionStore
+    
     # ==== Parameters
-    # k<~to_s>:: The key of the session parameter to set.
-    # v<~to_s>:: The value of the session parameter to set.
-    def []=(k, v) 
-      @data[k] = v
+    # ttl<Fixnum>:: Session validity time in seconds. Defaults to 1 hour.
+    def initialize(ttl=nil)
+      @sessions = Hash.new
+      @timestamps = Hash.new
+      @mutex = Mutex.new
+      @session_ttl = ttl || 60*60 # default 1 hour
+      start_timer
     end
-
+    
     # ==== Parameters
-    # k<~to_s>:: The key of the session parameter to retrieve.
+    # session_id<String>:: ID of the session to retrieve.
     #
     # ==== Returns
-    # String:: The value of the session parameter.
-    def [](k) 
-      @data[k] 
+    # ContainerSession:: The session corresponding to the ID.
+    def retrieve_session(session_id)
+      @mutex.synchronize {
+        @timestamps[session_id] = Time.now
+        @sessions[session_id]
+      }
     end
 
-    # Yields the session data to an each block.
-    #
-    # ==== Parameter
-    # &b:: The block to pass to each.
-    def each(&b) 
-      @data.each(&b) 
+    # ==== Parameters
+    # session_id<String>:: ID of the session to set.
+    # data<ContainerSession>:: The session to set.
+    def store_session(session_id, data)
+      @mutex.synchronize {
+        @timestamps[session_id] = Time.now
+        @sessions[session_id] = data
+      }
     end
-    
-    private
 
-    # Attempts to redirect any messages to the data object.
-    def method_missing(name, *args, &block)
-      @data.send(name, *args, &block)
+    # ==== Parameters
+    # session_id<String>:: ID of the session to delete.
+    def delete_session(session_id)
+      @mutex.synchronize {
+        @timestamps.delete(session_id)
+        @sessions.delete(session_id)
+      }
     end
 
-  end
-
-  # Used for handling multiple sessions stored in memory.
-  class MemorySessionContainer
-    class << self
-
-      # ==== Parameters
-      # ttl<Fixnum>:: Session validity time in seconds. Defaults to 1 hour.
-      #
-      # ==== Returns
-      # MemorySessionContainer:: The new session container.
-      def setup(ttl=nil)
-        @sessions = Hash.new
-        @timestamps = Hash.new
-        @mutex = Mutex.new
-        @session_ttl = ttl || 60*60 # default 1 hour
-        start_timer
-        self
-      end
-
-      # Creates a new session based on the options.
-      #
-      # ==== Parameters
-      # opts<Hash>:: The session options (see below).
-      #
-      # ==== Options (opts)
-      # :session_id<String>:: ID of the session to create in the container.
-      # :data<MemorySession>:: The session to create in the container.
-      def create(opts={})
-        self[opts[:session_id]] = opts[:data]
-      end
-
-      # ==== Parameters
-      # key<String>:: ID of the session to retrieve.
-      #
-      # ==== Returns
-      # MemorySession:: The session corresponding to the ID.
-      def [](key)
-        @mutex.synchronize {
-          @timestamps[key] = Time.now
-          @sessions[key]
-        }
+    # Deletes any sessions that have reached their maximum validity.
+    def reap_old_sessions
+      @timestamps.each do |session_id,stamp|
+        delete_session(session_id) if (stamp + @session_ttl) < Time.now 
       end
+      GC.start
+    end
 
-      # ==== Parameters
-      # key<String>:: ID of the session to set.
-      # val<MemorySession>:: The session to set.
-      def []=(key, val) 
-        @mutex.synchronize {
-          @timestamps[key] = Time.now
-          @sessions[key] = val
+    # Starts the timer that will eventually reap outdated sessions.
+    def start_timer
+      Thread.new do
+        loop {
+          sleep @session_ttl
+          reap_old_sessions
         } 
-      end
-
-      # ==== Parameters
-      # key<String>:: ID of the session to delete.
-      def delete(key)
-        @mutex.synchronize {
-          @sessions.delete(key)
-          @timestamps.delete(key)
-        }
-      end
-
-      # Deletes any sessions that have reached their maximum validity.
-      def reap_old_sessions
-        @timestamps.each do |key,stamp|
-          if stamp + @session_ttl < Time.now
-            delete(key)
-          end  
-        end
-        GC.start
-      end
-
-      # Starts the timer that will eventually reap outdated sessions.
-      def start_timer
-        Thread.new do
-          loop {
-            sleep @session_ttl
-            reap_old_sessions
-          } 
-        end  
-      end
-
-      # ==== Returns
-      # Array:: The sessions stored in this container.
-      def sessions
-        @sessions
       end  
-      
-    end # end singleton class
-
-  end # end MemorySessionContainer
-end
+    end
+    
+  end
 
-Merb::MemorySessionContainer.setup(Merb::Config[:memory_session_ttl])
+end

data/lib/merb-core/dispatch/session/store_container.rb

@@ -0,0 +1,145 @@
+module Merb
+  
+  class SessionStoreContainer < SessionContainer
+    
+    class_inheritable_accessor :store
+    attr_accessor  :_fingerprint
+    
+    # The class attribute :store holds a reference to an object that implements 
+    # the following interface (either as class or instance methods): 
+    #
+    # - retrieve_session(session_id) # returns data as Hash
+    # - store_session(session_id, data) # data should be a Hash
+    # - delete_session(session_id)
+    #
+    # You can use this session store directly by assigning to :store in your
+    # config/init.rb after_app_loads step, for example:
+    #
+    #   Merb::BootLoader.after_app_loads do
+    #     SessionStoreContainer.store = BarSession.new(:option => 'value')
+    #   end
+    #
+    # Or you can inherit from SessionStoreContainer to create a SessionContainer
+    # that delegates to its 'store' attribute.
+    #
+    #   class FooSession < SessionStoreContainer
+    #   
+    #     self.store = FooContainer 
+    #   
+    #   end
+    #
+    #   class FooContainer
+    #   
+    #     def self.retrieve_session(session_id)
+    #       ...
+    #     end
+    #   
+    #     def self.store_session(session_id, data)
+    #       ...
+    #     end
+    #   
+    #     def self.delete_session(session_id)
+    #       ...
+    #     end
+    #   
+    #   end    
+    
+    # When used directly, report as :store store
+    self.session_store_type = :store
+    
+    class << self
+
+      # Generates a new session ID and creates a new session.
+      #
+      # ==== Returns
+      # SessionStoreContainer:: The new session.
+      def generate
+        session = new(Merb::SessionMixin.rand_uuid)
+        session.needs_new_cookie = true
+        session
+      end
+
+      # Setup a new session.
+      #
+      # ==== Parameters
+      # request<Merb::Request>:: The Merb::Request that came in from Rack.
+      #
+      # ==== Returns
+      # SessionContainer:: a SessionContainer. If no sessions were found, 
+      # a new SessionContainer will be generated.
+      def setup(request)
+        session = retrieve(request.session_id)
+        request.session = session
+        # TODO Marshal.dump is slow - needs optimization
+        session._fingerprint = Marshal.dump(request.session.to_hash).hash
+        session
+      end
+            
+      private
+      
+      # ==== Parameters
+      # session_id<String:: The ID of the session to retrieve.
+      #
+      # ==== Returns
+      # SessionStoreContainer:: SessionStoreContainer instance with the session data. If no
+      #   sessions matched session_id, a new SessionStoreContainer will be generated.
+      #
+      # ==== Notes
+      # If there are persisted exceptions callbacks to execute, they all get executed
+      # when Memcache library raises an exception.
+      def retrieve(session_id)
+        unless session_id.blank?
+          begin
+            session_data = store.retrieve_session(session_id)
+          rescue => err
+            Merb.logger.warn!("Could not retrieve session from #{self.name}: #{err.message}")
+          end
+          # Not in container, but assume that cookie exists
+          session_data = new(session_id) if session_data.nil?
+        else
+          # No cookie...make a new session_id
+          session_data = generate
+        end
+        if session_data.is_a?(self)
+          session_data
+        else
+          # Recreate using the existing session as the data, when switching 
+          # from another session type for example, eg. cookie to memcached
+          # or when the data is just a hash
+          new(session_id).update(session_data)
+        end
+      end
+
+    end
+    
+    # Teardown and/or persist the current session.
+    #
+    # ==== Parameters
+    # request<Merb::Request>:: The Merb::Request that came in from Rack.
+    #
+    # ==== Notes
+    # The data (self) is converted to a Hash first, since a container might 
+    # choose to do a full Marshal on the data, which would make it persist 
+    # attributes like 'needs_new_cookie', which it shouldn't.
+    def finalize(request)
+      if _fingerprint != Marshal.dump(data = self.to_hash).hash
+        begin
+          store.store_session(request.session(self.class.session_store_type).session_id, data)
+        rescue => err
+          Merb.logger.warn!("Could not persist session to #{self.class.name}: #{err.message}")
+        end
+      end
+      if needs_new_cookie || Merb::SessionMixin.needs_new_cookie?
+        request.set_session_id_cookie(session_id)
+      end
+    end
+
+    # Regenerate the session ID.
+    def regenerate
+      store.delete_session(self.session_id)
+      self.session_id = Merb::SessionMixin.rand_uuid
+      store.store_session(self.session_id, self)
+    end
+    
+  end
+end