actionpack 4.2.10 → 7.2.0.rc1

data/lib/action_dispatch/middleware/session/abstract_store.rb

@@ -1,26 +1,27 @@
-require 'rack/utils'
-require 'rack/request'
-require 'rack/session/abstract/id'
-require 'action_dispatch/middleware/cookies'
-require 'action_dispatch/request/session'
+# frozen_string_literal: true
 
-module ActionDispatch
-  module Session
-    class SessionRestoreError < StandardError #:nodoc:
-      attr_reader :original_exception
+# :markup: markdown
 
-      def initialize(const_error)
-        @original_exception = const_error
+require "rack/utils"
+require "rack/request"
+require "rack/session/abstract/id"
+require "action_dispatch/middleware/cookies"
+require "action_dispatch/request/session"
 
-        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")
+module ActionDispatch
+  module Session
+    class SessionRestoreError < StandardError # :nodoc:
+      def initialize
+        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: #{$!.message} [#{$!.class}])\n")
+        set_backtrace $!.backtrace
       end
     end
 
     module Compatibility
       def initialize(app, options = {})
-        options[:key] ||= '_session_id'
+        options[:key] ||= "_session_id"
         super
       end
 
@@ -30,12 +31,15 @@ module ActionDispatch
         sid
       end
 
-    protected
-
-      def initialize_sid
+    private
+      def initialize_sid # :doc:
         @default_options.delete(:sidbits)
         @default_options.delete(:secure_random)
       end
+
+      def make_request(env)
+        ActionDispatch::Request.new env
+      end
     end
 
     module StaleSessionCheck
@@ -52,10 +56,10 @@ module ActionDispatch
       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 ':'
+            # 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 +69,13 @@ module ActionDispatch
     end
 
     module SessionObject # :nodoc:
-      def prepare_session(env)
-        Request::Session.create(self, env, @default_options)
+      def commit_session(req, res)
+        req.commit_csrf_token
+        super(req, res)
+      end
+
+      def prepare_session(req)
+        Request::Session.create(self, req, @default_options)
       end
 
       def loaded_session?(session)
@@ -74,17 +83,30 @@ 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(request, response, cookie)
+          request.cookie_jar[key] = cookie
+        end
+    end
+
+    class AbstractSecureStore < Rack::Session::Abstract::PersistedSecure
+      include Compatibility
+      include StaleSessionCheck
+      include SessionObject
 
-      def set_cookie(env, session_id, cookie)
-        request = ActionDispatch::Request.new(env)
-        request.cookie_jar[key] = cookie
+      def generate_sid
+        Rack::Session::SessionId.new(super)
       end
+
+      private
+        def set_cookie(request, response, cookie)
+          request.cookie_jar[key] = cookie
+        end
     end
   end
 end

data/lib/action_dispatch/middleware/session/cache_store.rb

@@ -1,13 +1,25 @@
-require 'action_dispatch/middleware/session/abstract_store'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/middleware/session/abstract_store"
 
 module ActionDispatch
   module Session
-    # Session store that uses an ActiveSupport::Cache::Store to store the sessions. This store is most useful
-    # if you don't store critical data in your sessions and you don't need them to live for extended periods
-    # of time.
-    class CacheStore < AbstractStore
-      # Create a new store. The cache to use can be passed in the <tt>:cache</tt> option. If it is
-      # not specified, <tt>Rails.cache</tt> will be used.
+    # # Action Dispatch Session CacheStore
+    #
+    # A session store that uses an ActiveSupport::Cache::Store to store the
+    # sessions. This store is most useful if you don't store critical data in your
+    # sessions and you don't need them to live for extended periods of time.
+    #
+    # #### Options
+    # *   `cache`         - The cache to use. If it is not specified, `Rails.cache`
+    #     will be used.
+    # *   `expire_after`  - The length of time a session will be stored before
+    #     automatically expiring. By default, the `:expires_in` option of the cache
+    #     is used.
+    #
+    class CacheStore < AbstractSecureStore
       def initialize(app, options = {})
         @cache = options[:cache] || Rails.cache
         options[:expire_after] ||= @cache.options[:expires_in]
@@ -15,18 +27,18 @@ module ActionDispatch
       end
 
       # Get a session from the cache.
-      def get_session(env, sid)
-        unless sid and session = @cache.read(cache_key(sid))
+      def find_session(env, sid)
+        unless sid && (session = get_session_with_fallback(sid))
           sid, session = generate_sid, {}
         end
         [sid, session]
       end
 
       # Set a session in the cache.
-      def set_session(env, sid, session, options)
-        key = cache_key(sid)
+      def write_session(env, sid, session, options)
+        key = cache_key(sid.private_id)
         if session
-          @cache.write(key, session, :expires_in => options[:expire_after])
+          @cache.write(key, session, expires_in: options[:expire_after])
         else
           @cache.delete(key)
         end
@@ -34,15 +46,20 @@ module ActionDispatch
       end
 
       # Remove a session from the cache.
-      def destroy_session(env, sid, options)
-        @cache.delete(cache_key(sid))
+      def delete_session(env, sid, options)
+        @cache.delete(cache_key(sid.private_id))
+        @cache.delete(cache_key(sid.public_id))
         generate_sid
       end
 
       private
         # Turn the session id into a cache key.
-        def cache_key(sid)
-          "_session_id:#{sid}"
+        def cache_key(id)
+          "_session_id:#{id}"
+        end
+
+        def get_session_with_fallback(sid)
+          @cache.read(cache_key(sid.private_id)) || @cache.read(cache_key(sid.public_id))
         end
     end
   end

data/lib/action_dispatch/middleware/session/cookie_store.rb

@@ -1,123 +1,129 @@
-require 'active_support/core_ext/hash/keys'
-require 'action_dispatch/middleware/session/abstract_store'
-require 'rack/session/cookie'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/hash/keys"
+require "action_dispatch/middleware/session/abstract_store"
+require "rack/session/cookie"
 
 module ActionDispatch
   module Session
-    # This cookie-based session store is the Rails default. It is
-    # dramatically faster than the alternatives.
+    # # Action Dispatch Session CookieStore
     #
-    # Sessions typically contain at most a user_id and flash message; both fit
-    # within the 4K cookie size limit. A CookieOverflow exception is raised if
-    # you attempt to store more than 4K of data.
+    # This cookie-based session store is the Rails default. It is dramatically
+    # faster than the alternatives.
     #
-    # The cookie jar used for storage is automatically configured to be the
-    # best possible option given your application's configuration.
+    # Sessions typically contain at most a user ID and flash message; both fit
+    # within the 4096 bytes cookie size limit. A `CookieOverflow` exception is
+    # raised if you attempt to store more than 4096 bytes of data.
     #
-    # If you only have secret_token set, your cookies will be signed, but
-    # not encrypted. This means a user cannot alter their +user_id+ without
-    # knowing your app's secret key, but can easily read their +user_id+. This
-    # was the default for Rails 3 apps.
+    # The cookie jar used for storage is automatically configured to be the best
+    # possible option given your application's configuration.
     #
-    # If you have secret_key_base set, your cookies will be encrypted. This
-    # goes a step further than signed cookies in that encrypted cookies cannot
+    # Your cookies will be encrypted using your application's `secret_key_base`.
+    # This 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
-    # be encrypted, and signed cookies generated by Rails 3 will be
-    # transparently read and encrypted to provide a smooth upgrade path.
+    # Configure your session store in an initializer:
     #
-    # Configure your session store in config/initializers/session_store.rb:
+    #     Rails.application.config.session_store :cookie_store, key: '_your_app_session'
     #
-    #   Rails.application.config.session_store :cookie_store, key: '_your_app_session'
+    # In the development and test environments your application's `secret_key_base`
+    # is generated by Rails and stored in a temporary file in
+    # `tmp/local_secret.txt`. In all other environments, it is stored encrypted in
+    # the `config/credentials.yml.enc` file.
     #
-    # Configure your secret key in config/secrets.yml:
+    # If your application was not updated to Rails 5.2 defaults, the
+    # `secret_key_base` will be found in the old `config/secrets.yml` file.
     #
-    #   development:
-    #     secret_key_base: 'secret key'
+    # Note that changing your `secret_key_base` will invalidate all existing
+    # session. Additionally, you should take care to make sure you are not relying
+    # on the ability to decode signed cookies generated by your app in external
+    # applications or JavaScript before changing it.
     #
-    # To generate a secret key for an existing application, run `rake secret`.
+    # 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:
     #
-    # 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.
-    # Note that you should wait to set secret_key_base until you have 100% of
-    # your userbase on Rails 4 and are reasonably sure you will not need to
-    # rollback to Rails 3. This is because cookies signed based on the new
-    # secret_key_base in Rails 4 are not backwards compatible with Rails 3.
-    # You are free to leave your existing secret_token in place, not set the
-    # new secret_key_base, and ignore the deprecation warnings until you are
-    # reasonably sure that your upgrade is otherwise complete. Additionally,
-    # you should take care to make sure you are not relying on the ability to
-    # decode signed cookies generated by your app in external applications or
-    # JavaScript before upgrading.
+    #     Rails.application.config.session_store :cookie_store, expire_after: 14.days
     #
-    # Note that changing the secret key will invalidate all existing sessions!
-    class CookieStore < Rack::Session::Abstract::ID
-      include Compatibility
-      include StaleSessionCheck
-      include SessionObject
+    # would set the session cookie to expire automatically 14 days after creation.
+    # Other useful options include `:key`, `:secure`, `:httponly`, and `:same_site`.
+    class CookieStore < AbstractSecureStore
+      class SessionId < DelegateClass(Rack::Session::SessionId)
+        attr_reader :cookie_value
+
+        def initialize(session_id, cookie_value = {})
+          super(session_id)
+          @cookie_value = cookie_value
+        end
+      end
+
+      DEFAULT_SAME_SITE = proc { |request| request.cookies_same_site_protection } # :nodoc:
 
-      def initialize(app, options={})
-        super(app, options.merge!(:cookie_only => true))
+      def initialize(app, options = {})
+        options[:cookie_only] = true
+        options[:same_site] = DEFAULT_SAME_SITE if !options.key?(:same_site)
+        super
       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.public_id } : {})
         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]
+          [Rack::Session::SessionId.new(data["session_id"]), data]
         end
       end
 
       private
-
-      def extract_session_id(env)
-        stale_session_check! do
-          unpacked_cookie_data(env)["session_id"]
+        def extract_session_id(req)
+          stale_session_check! do
+            sid = unpacked_cookie_data(req)["session_id"]
+            sid && Rack::Session::SessionId.new(sid)
+          end
         end
-      end
 
-      def unpacked_cookie_data(env)
-        env["action_dispatch.request.unsigned_session_cookie"] ||= begin
-          stale_session_check! do
-            if data = get_cookie(env)
-              data.stringify_keys!
+        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
-            data || {}
+            req.set_header k, v
           end
         end
-      end
 
-      def persistent_session_id!(data, sid=nil)
-        data ||= {}
-        data["session_id"] ||= sid || generate_sid
-        data
-      end
+        def persistent_session_id!(data, sid = nil)
+          data ||= {}
+          data["session_id"] ||= sid || generate_sid.public_id
+          data
+        end
 
-      def set_session(env, sid, session_data, options)
-        session_data["session_id"] = sid
-        session_data
-      end
+        def write_session(req, sid, session_data, options)
+          session_data["session_id"] = sid.public_id
+          SessionId.new(sid, session_data)
+        end
 
-      def set_cookie(env, session_id, cookie)
-        cookie_jar(env)[@key] = cookie
-      end
+        def set_cookie(request, session_id, cookie)
+          cookie_jar(request)[@key] = cookie
+        end
 
-      def get_cookie(env)
-        cookie_jar(env)[@key]
-      end
+        def get_cookie(req)
+          cookie_jar(req)[@key]
+        end
 
-      def cookie_jar(env)
-        request = ActionDispatch::Request.new(env)
-        request.cookie_jar.signed_or_encrypted
-      end
+        def cookie_jar(request)
+          request.cookie_jar.signed_or_encrypted
+        end
     end
   end
 end

data/lib/action_dispatch/middleware/session/mem_cache_store.rb

@@ -1,13 +1,25 @@
-require 'action_dispatch/middleware/session/abstract_store'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/middleware/session/abstract_store"
 begin
-  require 'rack/session/dalli'
+  require "rack/session/dalli"
 rescue LoadError => e
-  $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
+  warn "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end
 
 module ActionDispatch
   module Session
+    # # Action Dispatch Session MemCacheStore
+    #
+    # A session store that uses MemCache to implement storage.
+    #
+    # #### Options
+    # *   `expire_after`  - The length of time a session will be stored before
+    #     automatically expiring.
+    #
     class MemCacheStore < Rack::Session::Dalli
       include Compatibility
       include StaleSessionCheck

data/lib/action_dispatch/middleware/show_exceptions.rb

@@ -1,26 +1,28 @@
-require 'action_dispatch/http/request'
-require 'action_dispatch/middleware/exception_wrapper'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/middleware/exception_wrapper"
 
 module ActionDispatch
-  # This middleware rescues any exception returned by the application
-  # and calls an exceptions app that will wrap it in a format for the end user.
+  # # Action Dispatch ShowExceptions
+  #
+  # This middleware rescues any exception returned by the application and calls an
+  # exceptions app that will wrap it in a format for the end user.
+  #
+  # The exceptions app should be passed as a parameter on initialization of
+  # `ShowExceptions`. Every time there is an exception, `ShowExceptions` will
+  # store the exception in `env["action_dispatch.exception"]`, rewrite the
+  # `PATH_INFO` to the exception status code, and call the Rack app.
   #
-  # The exceptions app should be passed as parameter on initialization
-  # of ShowExceptions. Every time there is an exception, ShowExceptions will
-  # store the exception in env["action_dispatch.exception"], rewrite the
-  # PATH_INFO to the exception status code and call the rack app.
+  # In Rails applications, the exceptions app can be configured with
+  # `config.exceptions_app`, which defaults to ActionDispatch::PublicExceptions.
   #
-  # If the application returns a "X-Cascade" pass response, this middleware
-  # will send an empty response as result with the correct status code.
-  # If any exception happens inside the exceptions app, this middleware
-  # catches the exceptions and returns a FAILSAFE_RESPONSE.
+  # If the application returns a response with the `X-Cascade` header set to
+  # `"pass"`, this middleware will send an empty response as a result with the
+  # correct status code. If any exception happens inside the exceptions app, this
+  # middleware catches the exceptions and returns a failsafe response.
   class ShowExceptions
-    FAILSAFE_RESPONSE = [500, { 'Content-Type' => 'text/plain' },
-      ["500 Internal Server Error\n" \
-       "If you are the administrator of this website, then please read this web " \
-       "application's log file and/or the web server's log file to find out what " \
-       "went wrong."]]
-
     def initialize(app, exceptions_app)
       @app = app
       @exceptions_app = exceptions_app
@@ -29,30 +31,58 @@ module ActionDispatch
     def call(env)
       @app.call(env)
     rescue Exception => exception
-      if env['action_dispatch.show_exceptions'] == false
-        raise exception
+      request = ActionDispatch::Request.new env
+      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+      wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
+      request.set_header "action_dispatch.exception", wrapper.unwrapped_exception
+      request.set_header "action_dispatch.report_exception", !wrapper.rescue_response?
+
+      if wrapper.show?(request)
+        render_exception(request.dup, wrapper)
       else
-        render_exception(env, exception)
+        raise exception
       end
     end
 
     private
+      def render_exception(request, wrapper)
+        status = wrapper.status_code
+        request.set_header "action_dispatch.original_path", request.path_info
+        request.set_header "action_dispatch.original_request_method", request.raw_request_method
+        fallback_to_html_format_if_invalid_mime_type(request)
+        request.path_info = "/#{status}"
+        request.request_method = "GET"
+        response = @exceptions_app.call(request.env)
+        response[1][Constants::X_CASCADE] == "pass" ? pass_response(status) : response
+      rescue Exception => failsafe_error
+        $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
 
-    def render_exception(env, exception)
-      wrapper = ExceptionWrapper.new(env, exception)
-      status  = wrapper.status_code
-      env["action_dispatch.exception"] = wrapper.exception
-      env["action_dispatch.original_path"] = env["PATH_INFO"]
-      env["PATH_INFO"] = "/#{status}"
-      response = @exceptions_app.call(env)
-      response[1]['X-Cascade'] == 'pass' ? pass_response(status) : response
-    rescue Exception => failsafe_error
-      $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
-      FAILSAFE_RESPONSE
-    end
+        [500, { Rack::CONTENT_TYPE => "text/plain; charset=utf-8" },
+          ["500 Internal Server Error\n" \
+          "If you are the administrator of this website, then please read this web " \
+          "application's log file and/or the web server's log file to find out what " \
+          "went wrong."]]
+      end
 
-    def pass_response(status)
-      [status, {"Content-Type" => "text/html; charset=#{Response.default_charset}", "Content-Length" => "0"}, []]
-    end
+      def fallback_to_html_format_if_invalid_mime_type(request)
+        # If the MIME type for the request is invalid then the @exceptions_app may not
+        # be able to handle it. To make it easier to handle, we switch to HTML.
+        begin
+          request.content_mime_type
+        rescue ActionDispatch::Http::MimeNegotiation::InvalidType
+          request.set_header "CONTENT_TYPE", "text/html"
+        end
+
+        begin
+          request.formats
+        rescue ActionDispatch::Http::MimeNegotiation::InvalidType
+          request.set_header "HTTP_ACCEPT", "text/html"
+        end
+      end
+
+      def pass_response(status)
+        [status, { Rack::CONTENT_TYPE => "text/html; charset=#{Response.default_charset}",
+                  Rack::CONTENT_LENGTH => "0" }, []]
+      end
   end
 end