Rely on Rack::Session stores API for more compatibility across the Ruby world.

3 files changed, 76 insertions, 321 deletions

diff --git a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
index db0187c015..679ba7fc8e 100644
--- a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
@@ -1,5 +1,6 @@
 require 'rack/utils'
 require 'rack/request'
+require 'rack/session/abstract/id'
 require 'action_dispatch/middleware/cookies'
 require 'active_support/core_ext/object/blank'
 
@@ -8,252 +9,69 @@ module ActionDispatch
     class SessionRestoreError < StandardError #:nodoc:
     end
 
-    class AbstractStore
-      ENV_SESSION_KEY = 'rack.session'.freeze
-      ENV_SESSION_OPTIONS_KEY = 'rack.session.options'.freeze
-
-      # thin wrapper around Hash that allows us to lazily
-      # load session id into session_options
-      class OptionsHash < Hash
-        def initialize(by, env, default_options)
-          @by = by
-          @env = env
-          @session_id_loaded = false
-          merge!(default_options)
-        end
-
-        def [](key)
-          if key == :id
-            load_session_id! unless key?(:id) || has_session_id?
-          end
-          super
-        end
-
-      private
-
-        def has_session_id?
-          @session_id_loaded
-        end
-
-        def load_session_id!
-          self[:id] = @by.send(:extract_session_id, @env)
-          @session_id_loaded = true
-        end
-      end
-
-      class SessionHash < Hash
-        def initialize(by, env)
-          super()
-          @by = by
-          @env = env
-          @loaded = false
-        end
-
-        def [](key)
-          load_for_read!
-          super(key.to_s)
-        end
-
-        def has_key?(key)
-          load_for_read!
-          super(key.to_s)
-        end
-
-        def []=(key, value)
-          load_for_write!
-          super(key.to_s, value)
-        end
-
-        def clear
-          load_for_write!
-          super
-        end
-
-        def to_hash
-          load_for_read!
-          h = {}.replace(self)
-          h.delete_if { |k,v| v.nil? }
-          h
-        end
-
-        def update(hash)
-          load_for_write!
-          super(hash.stringify_keys)
-        end
-
-        def delete(key)
-          load_for_write!
-          super(key.to_s)
-        end
-
-        def inspect
-          load_for_read!
-          super
-        end
-
-        def exists?
-          return @exists if instance_variable_defined?(:@exists)
-          @exists = @by.send(:exists?, @env)
-        end
-
-        def loaded?
-          @loaded
-        end
-
-        def destroy
-          clear
-          @by.send(:destroy, @env) if defined?(@by) && @by
-          @env[ENV_SESSION_OPTIONS_KEY][:id] = nil if defined?(@env) && @env && @env[ENV_SESSION_OPTIONS_KEY]
-          @loaded = false
-        end
-
-        private
-
-          def load_for_read!
-            load! if !loaded? && exists?
-          end
-
-          def load_for_write!
-            load! unless loaded?
-          end
-
-          def load!
-            id, session = @by.send(:load_session, @env)
-            @env[ENV_SESSION_OPTIONS_KEY][:id] = id
-            replace(session.stringify_keys)
-            @loaded = true
-          end
-
+    module DestroyableSession
+      def destroy
+        clear
+        options = @env[Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY] if @env
+        options ||= {}
+        @by.send(:destroy_session, @env, options[:id], options) if @by
+        options[:id] = nil
+        @loaded = false
       end
+    end
 
-      DEFAULT_OPTIONS = {
-        :key =>           '_session_id',
-        :path =>          '/',
-        :domain =>        nil,
-        :expire_after =>  nil,
-        :secure =>        false,
-        :httponly =>      true,
-        :cookie_only =>   true
-      }
+    ::Rack::Session::Abstract::SessionHash.send :include, DestroyableSession
 
+    module Compatibility
       def initialize(app, options = {})
-        @app = app
-        @default_options = DEFAULT_OPTIONS.merge(options)
-        @key = @default_options.delete(:key).freeze
-        @cookie_only = @default_options.delete(:cookie_only)
-        ensure_session_key!
+        options[:key] ||= '_session_id'
+        super
       end
 
-      def call(env)
-        prepare!(env)
-        response = @app.call(env)
-
-        session_data = env[ENV_SESSION_KEY]
-        options = env[ENV_SESSION_OPTIONS_KEY]
-
-        if !session_data.is_a?(AbstractStore::SessionHash) || session_data.loaded? || options[:expire_after]
-          request = ActionDispatch::Request.new(env)
-
-          return response if (options[:secure] && !request.ssl?)
-
-          session_data.send(:load!) if session_data.is_a?(AbstractStore::SessionHash) && !session_data.loaded?
-
-          sid = options[:id] || generate_sid
-          session_data = session_data.to_hash
-
-          value = set_session(env, sid, session_data)
-          return response unless value
-
-          cookie = { :value => value }
-          if options[:expire_after]
-            cookie[:expires] = Time.now + options.delete(:expire_after)
-          end
-
-          set_cookie(request, cookie.merge!(options))
-        end
-
-        response
+      def generate_sid
+        ActiveSupport::SecureRandom.hex(16)
       end
+    end
 
-      private
-
-        def prepare!(env)
-          env[ENV_SESSION_KEY] = SessionHash.new(self, env)
-          env[ENV_SESSION_OPTIONS_KEY] = OptionsHash.new(self, env, @default_options)
-        end
-
-        def generate_sid
-          ActiveSupport::SecureRandom.hex(16)
-        end
-
-        def set_cookie(request, options)
-          if request.cookie_jar[@key] != options[:value] || !options[:expires].nil?
-            request.cookie_jar[@key] = options
-          end
-        end
-
-        def load_session(env)
-          stale_session_check! do
-            sid = current_session_id(env)
-            sid, session = get_session(env, sid)
-            [sid, session]
-          end
-        end
-
-        def extract_session_id(env)
-          stale_session_check! do
-            request = ActionDispatch::Request.new(env)
-            sid = request.cookies[@key]
-            sid ||= request.params[@key] unless @cookie_only
-            sid
-          end
-        end
-
-        def current_session_id(env)
-          env[ENV_SESSION_OPTIONS_KEY][:id]
-        end
+    module StaleSessionCheck
+      def load_session(env)
+        stale_session_check! { super }
+      end
 
-        def ensure_session_key!
-          if @key.blank?
-            raise ArgumentError, 'A key is required to write a ' +
-              'cookie containing the session data. Use ' +
-              'config.session_store SESSION_STORE, { :key => ' +
-              '"_myapp_session" } in config/application.rb'
-          end
-        end
+      def extract_session_id(env)
+        stale_session_check! { super }
+      end
 
-        def stale_session_check!
-          yield
-        rescue ArgumentError => argument_error
-          if argument_error.message =~ %r{undefined class/module ([\w:]*\w)}
-            begin
-              # Note that the regexp does not allow $1 to end with a ':'
-              $1.constantize
-            rescue LoadError, NameError => const_error
-              raise ActionDispatch::Session::SessionRestoreError, "Session contains objects whose class definition isn't available.\nRemember to require the classes for all objects kept in the session.\n(Original exception: #{const_error.message} [#{const_error.class}])\n"
-            end
-            retry
-          else
-            raise
+      def stale_session_check!
+        yield
+      rescue ArgumentError => argument_error
+        if argument_error.message =~ %r{undefined class/module ([\w:]*\w)}
+          begin
+            # Note that the regexp does not allow $1 to end with a ':'
+            $1.constantize
+          rescue LoadError, NameError => const_error
+            raise ActionDispatch::Session::SessionRestoreError, "Session contains objects whose class definition isn't available.\nRemember to require the classes for all objects kept in the session.\n(Original exception: #{const_error.message} [#{const_error.class}])\n"
           end
+          retry
+        else
+          raise
         end
+      end
+    end
 
-        def exists?(env)
-          current_session_id(env).present?
-        end
-
-        def get_session(env, sid)
-          raise '#get_session needs to be implemented.'
-        end
+    class AbstractStore < Rack::Session::Abstract::ID
+      include Compatibility
+      include StaleSessionCheck
 
-        def set_session(env, sid, session_data)
-          raise '#set_session needs to be implemented and should return ' <<
-            'the value to be stored in the cookie (usually the sid)'
-        end
+      def destroy_session(env, sid, options)
+        ActiveSupport::Deprecation.warn "Implementing #destroy in session stores is deprecated. " <<
+          "Please implement destroy_session(env, session_id, options) instead."
+        destroy(env)
+      end
 
-        def destroy(env)
-          raise '#destroy needs to be implemented.'
-        end
+      def destroy(env)
+        raise '#destroy needs to be implemented.'
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
index ca1494425f..9c9ccc62f5 100644
--- a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
@@ -1,5 +1,7 @@
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/object/blank'
+require 'action_dispatch/middleware/session/abstract_store'
+require 'rack/session/cookie'
 
 module ActionDispatch
   module Session
@@ -38,58 +40,32 @@ module ActionDispatch
     # "rake secret" and set the key in config/initializers/secret_token.rb.
     #
     # Note that changing digest or secret invalidates all existing sessions!
-    class CookieStore < AbstractStore
-
-      def initialize(app, options = {})
-        super(app, options.merge!(:cookie_only => true))
-        freeze
-      end
+    class CookieStore < Rack::Session::Cookie
+      include Compatibility
+      include StaleSessionCheck
 
       private
 
-        def load_session(env)
-          data = unpacked_cookie_data(env)
-          data = persistent_session_id!(data)
-          [data["session_id"], data]
-        end
-
-        def extract_session_id(env)
-          if data = unpacked_cookie_data(env)
-            data["session_id"]
-          else
-            nil
-          end
-        end
-
-        def unpacked_cookie_data(env)
-          env["action_dispatch.request.unsigned_session_cookie"] ||= begin
-            stale_session_check! do
-              request = ActionDispatch::Request.new(env)
-              if data = request.cookie_jar.signed[@key]
-                data.stringify_keys!
-              end
-              data || {}
+      def unpacked_cookie_data(env)
+        env["action_dispatch.request.unsigned_session_cookie"] ||= begin
+          stale_session_check! do
+            request = ActionDispatch::Request.new(env)
+            if data = request.cookie_jar.signed[@key]
+              data.stringify_keys!
             end
+            data || {}
           end
         end
+      end
 
-        def set_cookie(request, options)
-          request.cookie_jar.signed[@key] = options
-        end
-
-        def set_session(env, sid, session_data)
-          persistent_session_id!(session_data, sid)
-        end
-
-        def destroy(env)
-          # session data is stored on client; nothing to do here
-        end
+      def set_session(env, sid, session_data, options)
+        persistent_session_id!(session_data, sid)
+      end
 
-        def persistent_session_id!(data, sid=nil)
-          data ||= {}
-          data["session_id"] ||= sid || generate_sid
-          data
-        end
+      def set_cookie(env, session_id, cookie)
+        request = ActionDispatch::Request.new(env)
+        request.cookie_jar.signed[@key] = cookie
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb b/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
index 28e3dbd732..4dd9a946c2 100644
--- a/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
@@ -1,56 +1,17 @@
+require 'action_dispatch/middleware/session/abstract_store'
+require 'rack/session/memcache'
+
 module ActionDispatch
   module Session
-    class MemCacheStore < AbstractStore
+    class MemCacheStore < Rack::Session::Memcache
+      include Compatibility
+      include StaleSessionCheck
+
       def initialize(app, options = {})
         require 'memcache'
-
-        # Support old :expires option
         options[:expire_after] ||= options[:expires]
-
-        super
-
-        @default_options = {
-          :namespace => 'rack:session',
-          :memcache_server => 'localhost:11211'
-        }.merge(@default_options)
-
-        @pool = options[:cache] || MemCache.new(@default_options[:memcache_server], @default_options)
-        unless @pool.servers.any? { |s| s.alive? }
-          raise "#{self} unable to find server during initialization."
-        end
-        @mutex = Mutex.new
-
         super
       end
-
-      private
-        def get_session(env, sid)
-          sid ||= generate_sid
-          begin
-            session = @pool.get(sid) || {}
-          rescue MemCache::MemCacheError, Errno::ECONNREFUSED
-            session = {}
-          end
-          [sid, session]
-        end
-
-        def set_session(env, sid, session_data)
-          options = env['rack.session.options']
-          expiry  = options[:expire_after] || 0
-          @pool.set(sid, session_data, expiry)
-          sid
-        rescue MemCache::MemCacheError, Errno::ECONNREFUSED
-          false
-        end
-
-        def destroy(env)
-          if sid = current_session_id(env)
-            @pool.delete(sid)
-          end
-        rescue MemCache::MemCacheError, Errno::ECONNREFUSED
-          false
-        end
-
     end
   end
 end