actionpack 3.2.19 → 4.2.11.3

data/lib/action_dispatch/middleware/public_exceptions.rb

@@ -1,5 +1,14 @@
 module ActionDispatch
-  # A simple Rack application that renders exceptions in the given public path.
+  # When called, this middleware renders an error page. By default if an HTML
+  # response is expected it will render static error pages from the `/public`
+  # directory. For example when this middleware receives a 500 response it will
+  # render the template found in `/public/500.html`.
+  # If an internationalized locale is set, this middleware will attempt to render
+  # the template in `/public/500.<locale>.html`. If an internationalized template
+  # is not found it will fall back on `/public/500.html`.
+  #
+  # When a request with a content type other than HTML is made, this middleware
+  # will attempt to convert error information into the appropriate response type.
   class PublicExceptions
     attr_accessor :public_path
 
@@ -8,23 +17,39 @@ module ActionDispatch
     end
 
     def call(env)
-      status      = env["PATH_INFO"][1..-1]
-      locale_path = "#{public_path}/#{status}.#{I18n.locale}.html" if I18n.locale
-      path        = "#{public_path}/#{status}.html"
-
-      if locale_path && File.exist?(locale_path)
-        render(status, File.read(locale_path))
-      elsif File.exist?(path)
-        render(status, File.read(path))
+      status       = env["PATH_INFO"][1..-1]
+      request      = ActionDispatch::Request.new(env)
+      content_type = request.formats.first
+      body         = { :status => status, :error => Rack::Utils::HTTP_STATUS_CODES.fetch(status.to_i, Rack::Utils::HTTP_STATUS_CODES[500]) }
+
+      render(status, content_type, body)
+    end
+
+    private
+
+    def render(status, content_type, body)
+      format = "to_#{content_type.to_sym}" if content_type
+      if format && body.respond_to?(format)
+        render_format(status, content_type, body.public_send(format))
       else
-        [404, { "X-Cascade" => "pass" }, []]
+        render_html(status)
       end
     end
 
-    private
+    def render_format(status, content_type, body)
+      [status, {'Content-Type' => "#{content_type}; charset=#{ActionDispatch::Response.default_charset}",
+                'Content-Length' => body.bytesize.to_s}, [body]]
+    end
+
+    def render_html(status)
+      path = "#{public_path}/#{status}.#{I18n.locale}.html"
+      path = "#{public_path}/#{status}.html" unless (found = File.exist?(path))
 
-    def render(status, body)
-      [status, {'Content-Type' => "text/html; charset=#{Response.default_charset}", 'Content-Length' => body.bytesize.to_s}, [body]]
+      if found || File.exist?(path)
+        render_format(status, 'text/html', File.read(path))
+      else
+        [404, { "X-Cascade" => "pass" }, []]
+      end
     end
   end
-end
+end

data/lib/action_dispatch/middleware/reloader.rb

@@ -1,4 +1,4 @@
-require 'action_dispatch/middleware/body_proxy'
+require 'active_support/deprecation/reporting'
 
 module ActionDispatch
   # ActionDispatch::Reloader provides prepare and cleanup callbacks,
@@ -20,26 +20,33 @@ module ActionDispatch
   # classes before they are unloaded.
   #
   # By default, ActionDispatch::Reloader is included in the middleware stack
-  # only in the development environment; specifically, when config.cache_classes
+  # only in the development environment; specifically, when +config.cache_classes+
   # is false. Callbacks may be registered even when it is not included in the
-  # middleware stack, but are executed only when +ActionDispatch::Reloader.prepare!+
-  # or +ActionDispatch::Reloader.cleanup!+ are called manually.
+  # middleware stack, but are executed only when <tt>ActionDispatch::Reloader.prepare!</tt>
+  # or <tt>ActionDispatch::Reloader.cleanup!</tt> are called manually.
   #
   class Reloader
     include ActiveSupport::Callbacks
+    include ActiveSupport::Deprecation::Reporting
 
-    define_callbacks :prepare, :scope => :name
-    define_callbacks :cleanup, :scope => :name
+    define_callbacks :prepare
+    define_callbacks :cleanup
 
     # Add a prepare callback. Prepare callbacks are run before each request, prior
     # to ActionDispatch::Callback's before callbacks.
     def self.to_prepare(*args, &block)
+      unless block_given?
+        warn "to_prepare without a block is deprecated. Please use a block"
+      end
       set_callback(:prepare, *args, &block)
     end
 
     # Add a cleanup callback. Cleanup callbacks are run after each request is
     # complete (after #close is called on the response body).
     def self.to_cleanup(*args, &block)
+      unless block_given?
+        warn "to_cleanup without a block is deprecated. Please use a block"
+      end
       set_callback(:cleanup, *args, &block)
     end
 
@@ -62,8 +69,10 @@ module ActionDispatch
     def call(env)
       @validated = @condition.call
       prepare!
+
       response = @app.call(env)
-      response[2] = ActionDispatch::BodyProxy.new(response[2]) { cleanup! }
+      response[2] = ::Rack::BodyProxy.new(response[2]) { cleanup! }
+
       response
     rescue Exception
       cleanup!

data/lib/action_dispatch/middleware/remote_ip.rb

@@ -1,80 +1,172 @@
+require 'ipaddr'
+
 module ActionDispatch
+  # This middleware calculates the IP address of the remote client that is
+  # making the request. It does this by checking various headers that could
+  # contain the address, and then picking the last-set address that is not
+  # on the list of trusted IPs. This follows the precedent set by e.g.
+  # {the Tomcat server}[https://issues.apache.org/bugzilla/show_bug.cgi?id=50453],
+  # with {reasoning explained at length}[http://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection]
+  # by @gingerlime. A more detailed explanation of the algorithm is given
+  # at GetIp#calculate_ip.
+  #
+  # Some Rack servers concatenate repeated headers, like {HTTP RFC 2616}[http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2]
+  # requires. Some Rack servers simply drop preceding headers, and only report
+  # the value that was {given in the last header}[http://andre.arko.net/2011/12/26/repeated-headers-and-ruby-web-servers].
+  # If you are behind multiple proxy servers (like NGINX to HAProxy to Unicorn)
+  # then you should test your Rack server to make sure your data is good.
+  #
+  # IF YOU DON'T USE A PROXY, THIS MAKES YOU VULNERABLE TO IP SPOOFING.
+  # This middleware assumes that there is at least one proxy sitting around
+  # and setting headers with the client's remote IP address. If you don't use
+  # a proxy, because you are hosted on e.g. Heroku without SSL, any client can
+  # claim to have any IP address by setting the X-Forwarded-For header. If you
+  # care about that, then you need to explicitly drop or ignore those headers
+  # sometime before this middleware runs.
   class RemoteIp
-    class IpSpoofAttackError < StandardError ; end
-
-    # IP addresses that are "trusted proxies" that can be stripped from
-    # the comma-delimited list in the X-Forwarded-For header. See also:
-    # http://en.wikipedia.org/wiki/Private_network#Private_IPv4_address_spaces
-    TRUSTED_PROXIES = %r{
-      ^127\.0\.0\.1$                | # localhost
-      ^(10                          | # private IP 10.x.x.x
-        172\.(1[6-9]|2[0-9]|3[0-1]) | # private IP in the range 172.16.0.0 .. 172.31.255.255
-        192\.168                      # private IP 192.168.x.x
-       )\.
-    }x
+    class IpSpoofAttackError < StandardError; end
+
+    # The default trusted IPs list simply includes IP addresses that are
+    # guaranteed by the IP specification to be private addresses. Those will
+    # not be the ultimate client IP in production, and so are discarded. See
+    # http://en.wikipedia.org/wiki/Private_network for details.
+    TRUSTED_PROXIES = [
+      "127.0.0.1",      # localhost IPv4
+      "::1",            # localhost IPv6
+      "fc00::/7",       # private IPv6 range fc00::/7
+      "10.0.0.0/8",     # private IPv4 range 10.x.x.x
+      "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
+      "192.168.0.0/16", # private IPv4 range 192.168.x.x
+    ].map { |proxy| IPAddr.new(proxy) }
 
     attr_reader :check_ip, :proxies
 
+    # Create a new +RemoteIp+ middleware instance.
+    #
+    # The +check_ip_spoofing+ option is on by default. When on, an exception
+    # is raised if it looks like the client is trying to lie about its own IP
+    # address. It makes sense to turn off this check on sites aimed at non-IP
+    # clients (like WAP devices), or behind proxies that set headers in an
+    # incorrect or confusing way (like AWS ELB).
+    #
+    # The +custom_proxies+ argument can take an Array of string, IPAddr, or
+    # Regexp objects which will be used instead of +TRUSTED_PROXIES+. If a
+    # single string, IPAddr, or Regexp object is provided, it will be used in
+    # addition to +TRUSTED_PROXIES+. Any proxy setup will put the value you
+    # want in the middle (or at the beginning) of the X-Forwarded-For list,
+    # with your proxy servers after it. If your proxies aren't removed, pass
+    # them in via the +custom_proxies+ parameter. That way, the middleware will
+    # ignore those IP addresses, and return the one that you want.
     def initialize(app, check_ip_spoofing = true, custom_proxies = nil)
       @app = app
       @check_ip = check_ip_spoofing
-      if custom_proxies
-        custom_regexp = Regexp.new(custom_proxies)
-        @proxies = Regexp.union(TRUSTED_PROXIES, custom_regexp)
+      @proxies = if custom_proxies.blank?
+        TRUSTED_PROXIES
+      elsif custom_proxies.respond_to?(:any?)
+        custom_proxies
       else
-        @proxies = TRUSTED_PROXIES
+        Array(custom_proxies) + TRUSTED_PROXIES
       end
     end
 
+    # Since the IP address may not be needed, we store the object here
+    # without calculating the IP to keep from slowing down the majority of
+    # requests. For those requests that do need to know the IP, the
+    # GetIp#calculate_ip method will calculate the memoized client IP address.
     def call(env)
       env["action_dispatch.remote_ip"] = GetIp.new(env, self)
       @app.call(env)
     end
 
+    # The GetIp class exists as a way to defer processing of the request data
+    # into an actual IP address. If the ActionDispatch::Request#remote_ip method
+    # is called, this class will calculate the value and then memoize it.
     class GetIp
       def initialize(env, middleware)
-        @env          = env
-        @middleware   = middleware
-        @calculated_ip = false
+        @env      = env
+        @check_ip = middleware.check_ip
+        @proxies  = middleware.proxies
       end
 
-      # Determines originating IP address. REMOTE_ADDR is the standard
-      # but will be wrong if the user is behind a proxy. Proxies will set
-      # HTTP_CLIENT_IP and/or HTTP_X_FORWARDED_FOR, so we prioritize those.
-      # HTTP_X_FORWARDED_FOR may be a comma-delimited list in the case of
-      # multiple chained proxies. The last address which is not a known proxy
-      # will be the originating IP.
+      # Sort through the various IP address headers, looking for the IP most
+      # likely to be the address of the actual remote client making this
+      # request.
+      #
+      # REMOTE_ADDR will be correct if the request is made directly against the
+      # Ruby process, on e.g. Heroku. When the request is proxied by another
+      # server like HAProxy or NGINX, the IP address that made the original
+      # request will be put in an X-Forwarded-For header. If there are multiple
+      # proxies, that header may contain a list of IPs. Other proxy services
+      # set the Client-Ip header instead, so we check that too.
+      #
+      # As discussed in {this post about Rails IP Spoofing}[http://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection/],
+      # while the first IP in the list is likely to be the "originating" IP,
+      # it could also have been set by the client maliciously.
+      #
+      # In order to find the first address that is (probably) accurate, we
+      # take the list of IPs, remove known and trusted proxies, and then take
+      # the last address left, which was presumably set by one of those proxies.
       def calculate_ip
-        client_ip     = @env['HTTP_CLIENT_IP']
-        forwarded_ips = ips_from('HTTP_X_FORWARDED_FOR')
-        remote_addrs  = ips_from('REMOTE_ADDR')
+        # Set by the Rack web server, this is a single value.
+        remote_addr = ips_from('REMOTE_ADDR').last
 
-        check_ip = client_ip && forwarded_ips.present? && @middleware.check_ip
-        if check_ip && !forwarded_ips.include?(client_ip)
+        # Could be a CSV list and/or repeated headers that were concatenated.
+        client_ips    = ips_from('HTTP_CLIENT_IP').reverse
+        forwarded_ips = ips_from('HTTP_X_FORWARDED_FOR').reverse
+
+        # +Client-Ip+ and +X-Forwarded-For+ should not, generally, both be set.
+        # If they are both set, it means that this request passed through two
+        # proxies with incompatible IP header conventions, and there is no way
+        # for us to determine which header is the right one after the fact.
+        # Since we have no idea, we give up and explode.
+        should_check_ip = @check_ip && client_ips.last && forwarded_ips.last
+        if should_check_ip && !forwarded_ips.include?(client_ips.last)
           # We don't know which came from the proxy, and which from the user
-          raise IpSpoofAttackError, "IP spoofing attack?!" \
-            "HTTP_CLIENT_IP=#{@env['HTTP_CLIENT_IP'].inspect}" \
+          raise IpSpoofAttackError, "IP spoofing attack?! " +
+            "HTTP_CLIENT_IP=#{@env['HTTP_CLIENT_IP'].inspect} " +
             "HTTP_X_FORWARDED_FOR=#{@env['HTTP_X_FORWARDED_FOR'].inspect}"
         end
 
-        not_proxy = client_ip || forwarded_ips.last || remote_addrs.first
+        # We assume these things about the IP headers:
+        #
+        #   - X-Forwarded-For will be a list of IPs, one per proxy, or blank
+        #   - Client-Ip is propagated from the outermost proxy, or is blank
+        #   - REMOTE_ADDR will be the IP that made the request to Rack
+        ips = [forwarded_ips, client_ips, remote_addr].flatten.compact
 
-        # Return first REMOTE_ADDR if there are no other options
-        not_proxy || ips_from('REMOTE_ADDR', :allow_proxies).first
+        # If every single IP option is in the trusted list, just return REMOTE_ADDR
+        filter_proxies(ips).first || remote_addr
       end
 
+      # Memoizes the value returned by #calculate_ip and returns it for
+      # ActionDispatch::Request to use.
       def to_s
-        return @ip if @calculated_ip
-        @calculated_ip = true
-        @ip = calculate_ip
+        @ip ||= calculate_ip
       end
 
     protected
 
-      def ips_from(header, allow_proxies = false)
+      def ips_from(header)
+        # Split the comma-separated list into an array of strings
         ips = @env[header] ? @env[header].strip.split(/[,\s]+/) : []
-        allow_proxies ? ips : ips.reject{|ip| ip =~ @middleware.proxies }
+        ips.select do |ip|
+          begin
+            # Only return IPs that are valid according to the IPAddr#new method
+            range = IPAddr.new(ip).to_range
+            # we want to make sure nobody is sneaking a netmask in
+            range.begin == range.end
+          rescue ArgumentError
+            nil
+          end
+        end
       end
+
+      def filter_proxies(ips)
+        ips.reject do |ip|
+          @proxies.any? { |proxy| proxy === ip }
+        end
+      end
+
     end
 
   end

data/lib/action_dispatch/middleware/request_id.rb

@@ -1,12 +1,11 @@
 require 'securerandom'
 require 'active_support/core_ext/string/access'
-require 'active_support/core_ext/object/blank'
 
 module ActionDispatch
   # Makes a unique request id available to the action_dispatch.request_id env variable (which is then accessible through
   # ActionDispatch::Request#uuid) and sends the same id to the client via the X-Request-Id header.
   #
-  # The unique request id is either based off the X-Request-Id header in the request, which would typically be generated
+  # The unique request id is either based on the X-Request-Id header in the request, which would typically be generated
   # by a firewall, load balancer, or the web server, or, if this header is not available, a random uuid. If the
   # header is accepted from the outside world, we sanitize it to a max of 255 chars and alphanumeric and dashes only.
   #
@@ -19,10 +18,7 @@ module ActionDispatch
 
     def call(env)
       env["action_dispatch.request_id"] = external_request_id(env) || internal_request_id
-      status, headers, body = @app.call(env)
-
-      headers["X-Request-Id"] = env["action_dispatch.request_id"]
-      [ status, headers, body ]
+      @app.call(env).tap { |_status, headers, _body| headers["X-Request-Id"] = env["action_dispatch.request_id"] }
     end
 
     private
@@ -33,7 +29,7 @@ module ActionDispatch
       end
 
       def internal_request_id
-        SecureRandom.hex(16)
+        SecureRandom.uuid
       end
   end
 end

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

@@ -2,37 +2,31 @@ require 'rack/utils'
 require 'rack/request'
 require 'rack/session/abstract/id'
 require 'action_dispatch/middleware/cookies'
-require 'active_support/core_ext/object/blank'
+require 'action_dispatch/request/session'
 
 module ActionDispatch
   module Session
     class SessionRestoreError < StandardError #:nodoc:
-    end
+      attr_reader :original_exception
+
+      def initialize(const_error)
+        @original_exception = const_error
 
-    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
+        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")
       end
     end
 
-    ::Rack::Session::Abstract::SessionHash.send :include, DestroyableSession
-
     module Compatibility
       def initialize(app, options = {})
         options[:key] ||= '_session_id'
-        # FIXME Rack's secret is not being used
-        options[:secret] ||= SecureRandom.hex(30)
         super
       end
 
       def generate_sid
         sid = SecureRandom.hex(16)
-        sid.encode!('UTF-8') if sid.respond_to?(:encode!)
+        sid.encode!(Encoding::UTF_8)
         sid
       end
 
@@ -60,11 +54,8 @@ module ActionDispatch
           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.\n" +
-              "Remember to require the classes for all objects kept in the session.\n" +
-              "(Original exception: #{const_error.message} [#{const_error.class}])\n"
+          rescue LoadError, NameError => e
+            raise ActionDispatch::Session::SessionRestoreError, e, e.backtrace
           end
           retry
         else
@@ -73,9 +64,20 @@ module ActionDispatch
       end
     end
 
+    module SessionObject # :nodoc:
+      def prepare_session(env)
+        Request::Session.create(self, env, @default_options)
+      end
+
+      def loaded_session?(session)
+        !session.is_a?(Request::Session) || session.loaded?
+      end
+    end
+
     class AbstractStore < Rack::Session::Abstract::ID
       include Compatibility
       include StaleSessionCheck
+      include SessionObject
 
       private
 

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

@@ -16,9 +16,9 @@ module ActionDispatch
 
       # Get a session from the cache.
       def get_session(env, sid)
-        sid ||= generate_sid
-        session = @cache.read(cache_key(sid))
-        session ||= {}
+        unless sid and session = @cache.read(cache_key(sid))
+          sid, session = generate_sid, {}
+        end
         [sid, session]
       end
 

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

@@ -1,53 +1,93 @@
 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
-    # This cookie-based session store is the Rails default. Sessions typically
-    # contain at most a user_id and flash message; both fit within the 4K cookie
-    # size limit. Cookie-based sessions are dramatically faster than the
-    # alternatives.
+    # This cookie-based session store is the Rails default. It is
+    # dramatically faster than the alternatives.
     #
-    # If you have more than 4K of session data or don't want your data to be
-    # visible to the user, pick another session store.
+    # 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.
     #
-    # CookieOverflow is raised if you attempt to store more than 4K of data.
+    # The cookie jar used for storage is automatically configured to be the
+    # best possible option given your application's configuration.
     #
-    # A message digest is included with the cookie to ensure data integrity:
-    # a user cannot alter his +user_id+ without knowing the secret key
-    # included in the hash. New apps are generated with a pregenerated secret
-    # in config/environment.rb. Set your own for old apps you're upgrading.
+    # 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.
     #
-    # Session options:
+    # 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
+    # be altered or read by users. This is the default starting in Rails 4.
     #
-    # * <tt>:secret</tt>: An application-wide key string. It's important that
-    #   the secret is not vulnerable to a dictionary attack. Therefore, you
-    #   should choose a secret consisting of random numbers and letters and
-    #   more than 30 characters.
+    # 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.
     #
-    #     :secret => '449fe2e7daee471bffae2fd8dc02313d'
+    # Configure your session store in config/initializers/session_store.rb:
     #
-    # * <tt>:digest</tt>: The message digest algorithm used to verify session
-    #   integrity defaults to 'SHA1' but may be any digest provided by OpenSSL,
-    #   such as 'MD5', 'RIPEMD160', 'SHA256', etc.
+    #   Rails.application.config.session_store :cookie_store, key: '_your_app_session'
     #
-    # To generate a secret key for an existing application, run
-    # "rake secret" and set the key in config/initializers/secret_token.rb.
+    # Configure your secret key in config/secrets.yml:
     #
-    # Note that changing digest or secret invalidates all existing sessions!
-    class CookieStore < Rack::Session::Cookie
+    #   development:
+    #     secret_key_base: 'secret key'
+    #
+    # To generate a secret key for an existing application, run `rake 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.
+    # 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.
+    #
+    # Note that changing the secret key will invalidate all existing sessions!
+    class CookieStore < Rack::Session::Abstract::ID
       include Compatibility
       include StaleSessionCheck
+      include SessionObject
+
+      def initialize(app, options={})
+        super(app, options.merge!(:cookie_only => true))
+      end
+
+      def destroy_session(env, 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 } : {}
+        new_sid
+      end
+
+      def load_session(env)
+        stale_session_check! do
+          data = unpacked_cookie_data(env)
+          data = persistent_session_id!(data)
+          [data["session_id"], data]
+        end
+      end
 
       private
 
+      def extract_session_id(env)
+        stale_session_check! do
+          unpacked_cookie_data(env)["session_id"]
+        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]
+            if data = get_cookie(env)
               data.stringify_keys!
             end
             data || {}
@@ -55,13 +95,28 @@ module ActionDispatch
         end
       end
 
+      def persistent_session_id!(data, sid=nil)
+        data ||= {}
+        data["session_id"] ||= sid || generate_sid
+        data
+      end
+
       def set_session(env, sid, session_data, options)
-        session_data.merge!("session_id" => sid)
+        session_data["session_id"] = sid
+        session_data
       end
 
       def set_cookie(env, session_id, cookie)
+        cookie_jar(env)[@key] = cookie
+      end
+
+      def get_cookie(env)
+        cookie_jar(env)[@key]
+      end
+
+      def cookie_jar(env)
         request = ActionDispatch::Request.new(env)
-        request.cookie_jar.signed[@key] = cookie
+        request.cookie_jar.signed_or_encrypted
       end
     end
   end

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

@@ -1,14 +1,19 @@
 require 'action_dispatch/middleware/session/abstract_store'
-require 'rack/session/memcache'
+begin
+  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"
+  raise e
+end
 
 module ActionDispatch
   module Session
-    class MemCacheStore < Rack::Session::Memcache
+    class MemCacheStore < Rack::Session::Dalli
       include Compatibility
       include StaleSessionCheck
+      include SessionObject
 
       def initialize(app, options = {})
-        require 'memcache'
         options[:expire_after] ||= options[:expires]
         super
       end