diff options
Diffstat (limited to 'actionpack/lib/action_dispatch/middleware/session')
3 files changed, 47 insertions, 39 deletions
| diff --git a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb index 84df55fd5a..5fb5953811 100644 --- a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb +++ b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb @@ -7,14 +7,22 @@ require 'action_dispatch/request/session'  module ActionDispatch    module Session      class SessionRestoreError < StandardError #:nodoc: -      attr_reader :original_exception -      def initialize(const_error) -        @original_exception = const_error +      def initialize(const_error = nil) +        if const_error +          ActiveSupport::Deprecation.warn("Passing #original_exception is deprecated and has no effect. " \ +                                          "Exceptions will automatically capture the original exception.", caller) +        end          super("Session contains objects whose class definition isn't available.\n" +            "Remember to require the classes for all objects kept in the session.\n" + -          "(Original exception: #{const_error.message} [#{const_error.class}])\n") +          "(Original exception: #{$!.message} [#{$!.class}])\n") +        set_backtrace $!.backtrace +      end + +      def original_exception +        ActiveSupport::Deprecation.warn("#original_exception is deprecated. Use #cause instead.", caller) +        cause        end      end @@ -36,6 +44,11 @@ module ActionDispatch          @default_options.delete(:sidbits)          @default_options.delete(:secure_random)        end + +      private +      def make_request(env) +        ActionDispatch::Request.new env +      end      end      module StaleSessionCheck @@ -54,8 +67,8 @@ module ActionDispatch            begin              # Note that the regexp does not allow $1 to end with a ':'              $1.constantize -          rescue LoadError, NameError => e -            raise ActionDispatch::Session::SessionRestoreError, e, e.backtrace +          rescue LoadError, NameError +            raise ActionDispatch::Session::SessionRestoreError            end            retry          else @@ -65,8 +78,8 @@ module ActionDispatch      end      module SessionObject # :nodoc: -      def prepare_session(env) -        Request::Session.create(self, env, @default_options) +      def prepare_session(req) +        Request::Session.create(self, req, @default_options)        end        def loaded_session?(session) @@ -74,15 +87,14 @@ module ActionDispatch        end      end -    class AbstractStore < Rack::Session::Abstract::ID +    class AbstractStore < Rack::Session::Abstract::Persisted        include Compatibility        include StaleSessionCheck        include SessionObject        private -      def set_cookie(env, session_id, cookie) -        request = ActionDispatch::Request.new(env) +      def set_cookie(request, session_id, cookie)          request.cookie_jar[key] = cookie        end      end diff --git a/actionpack/lib/action_dispatch/middleware/session/cache_store.rb b/actionpack/lib/action_dispatch/middleware/session/cache_store.rb index 857e49a682..589ae46e38 100644 --- a/actionpack/lib/action_dispatch/middleware/session/cache_store.rb +++ b/actionpack/lib/action_dispatch/middleware/session/cache_store.rb @@ -18,7 +18,7 @@ module ActionDispatch        end        # Get a session from the cache. -      def get_session(env, sid) +      def find_session(env, sid)          unless sid and session = @cache.read(cache_key(sid))            sid, session = generate_sid, {}          end @@ -26,7 +26,7 @@ module ActionDispatch        end        # Set a session in the cache. -      def set_session(env, sid, session, options) +      def write_session(env, sid, session, options)          key = cache_key(sid)          if session            @cache.write(key, session, :expires_in => options[:expire_after]) @@ -37,7 +37,7 @@ module ActionDispatch        end        # Remove a session from the cache. -      def destroy_session(env, sid, options) +      def delete_session(env, sid, options)          @cache.delete(cache_key(sid))          generate_sid        end diff --git a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb index d8f9614904..dec9c60ef2 100644 --- a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb +++ b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb @@ -23,7 +23,7 @@ module ActionDispatch      # goes a step further than signed cookies in that encrypted cookies cannot      # be altered or read by users. This is the default starting in Rails 4.      # -    # If you have both secret_token and secret_key base set, your cookies will +    # If you have both secret_token and secret_key_base set, your cookies will      # be encrypted, and signed cookies generated by Rails 3 will be      # transparently read and encrypted to provide a smooth upgrade path.      # @@ -36,7 +36,7 @@ module ActionDispatch      #   development:      #     secret_key_base: 'secret key'      # -    # To generate a secret key for an existing application, run `rake secret`. +    # To generate a secret key for an existing application, run `rails secret`.      #      # If you are upgrading an existing Rails 3 app, you should leave your      # existing secret_token in place and simply add the new secret_key_base. @@ -53,7 +53,7 @@ module ActionDispatch      #      # Note that changing the secret key will invalidate all existing sessions!      # -    # Because CookieStore extends Rack::Session::Abstract::ID, many of the +    # Because CookieStore extends Rack::Session::Abstract::Persisted, many of the      # options described there can be used to customize the session cookie that      # is generated. For example:      # @@ -62,25 +62,21 @@ module ActionDispatch      # would set the session cookie to expire automatically 14 days after creation.      # Other useful options include <tt>:key</tt>, <tt>:secure</tt> and      # <tt>:httponly</tt>. -    class CookieStore < Rack::Session::Abstract::ID -      include Compatibility -      include StaleSessionCheck -      include SessionObject - +    class CookieStore < AbstractStore        def initialize(app, options={})          super(app, options.merge!(:cookie_only => true))        end -      def destroy_session(env, session_id, options) +      def delete_session(req, session_id, options)          new_sid = generate_sid unless options[:drop]          # Reset hash and Assign the new session id -        env["action_dispatch.request.unsigned_session_cookie"] = new_sid ? { "session_id" => new_sid } : {} +        req.set_header("action_dispatch.request.unsigned_session_cookie", new_sid ? { "session_id" => new_sid } : {})          new_sid        end -      def load_session(env) +      def load_session(req)          stale_session_check! do -          data = unpacked_cookie_data(env) +          data = unpacked_cookie_data(req)            data = persistent_session_id!(data)            [data["session_id"], data]          end @@ -88,20 +84,21 @@ module ActionDispatch        private -      def extract_session_id(env) +      def extract_session_id(req)          stale_session_check! do -          unpacked_cookie_data(env)["session_id"] +          unpacked_cookie_data(req)["session_id"]          end        end -      def unpacked_cookie_data(env) -        env["action_dispatch.request.unsigned_session_cookie"] ||= begin -          stale_session_check! do -            if data = get_cookie(env) +      def unpacked_cookie_data(req) +        req.fetch_header("action_dispatch.request.unsigned_session_cookie") do |k| +          v = stale_session_check! do +            if data = get_cookie(req)                data.stringify_keys!              end              data || {}            end +          req.set_header k, v          end        end @@ -111,21 +108,20 @@ module ActionDispatch          data        end -      def set_session(env, sid, session_data, options) +      def write_session(req, sid, session_data, options)          session_data["session_id"] = sid          session_data        end -      def set_cookie(env, session_id, cookie) -        cookie_jar(env)[@key] = cookie +      def set_cookie(request, session_id, cookie) +        cookie_jar(request)[@key] = cookie        end -      def get_cookie(env) -        cookie_jar(env)[@key] +      def get_cookie(req) +        cookie_jar(req)[@key]        end -      def cookie_jar(env) -        request = ActionDispatch::Request.new(env) +      def cookie_jar(request)          request.cookie_jar.signed_or_encrypted        end      end | 
