actionpack 3.1.12 → 3.2.0.rc1

data/lib/action_dispatch/middleware/remote_ip.rb

@@ -2,50 +2,80 @@ module ActionDispatch
   class RemoteIp
     class IpSpoofAttackError < StandardError ; end
 
-    class RemoteIpGetter
-      def initialize(env, check_ip_spoofing, trusted_proxies)
-        @env = env
-        @check_ip_spoofing = check_ip_spoofing
-        @trusted_proxies = trusted_proxies
+    # 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
+
+    attr_reader :check_ip, :proxies
+
+    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)
+      else
+        @proxies = TRUSTED_PROXIES
       end
+    end
 
-      def remote_addrs
-        @remote_addrs ||= begin
-          list = @env['REMOTE_ADDR'] ? @env['REMOTE_ADDR'].split(/[,\s]+/) : []
-          list.reject { |addr| addr =~ @trusted_proxies }
-        end
+    def call(env)
+      env["action_dispatch.remote_ip"] = GetIp.new(env, self)
+      @app.call(env)
+    end
+
+    class GetIp
+      def initialize(env, middleware)
+        @env          = env
+        @middleware   = middleware
+        @calculated_ip = false
       end
 
-      def to_s
-        return remote_addrs.first if remote_addrs.any?
-
-        forwarded_ips = @env['HTTP_X_FORWARDED_FOR'] ? @env['HTTP_X_FORWARDED_FOR'].strip.split(/[,\s]+/) : []
-
-        if client_ip = @env['HTTP_CLIENT_IP']
-          if @check_ip_spoofing && !forwarded_ips.include?(client_ip)
-            # 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}" \
-              "HTTP_X_FORWARDED_FOR=#{@env['HTTP_X_FORWARDED_FOR'].inspect}"
-          end
-          return client_ip
+      # 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.
+      def calculate_ip
+        client_ip     = @env['HTTP_CLIENT_IP']
+        forwarded_ips = ips_from('HTTP_X_FORWARDED_FOR')
+        remote_addrs  = ips_from('REMOTE_ADDR')
+
+        check_ip = client_ip && @middleware.check_ip
+        if check_ip && !forwarded_ips.include?(client_ip)
+          # 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}" \
+            "HTTP_X_FORWARDED_FOR=#{@env['HTTP_X_FORWARDED_FOR'].inspect}"
         end
 
-        return forwarded_ips.reject { |ip| ip =~ @trusted_proxies }.last || @env["REMOTE_ADDR"]
+        not_proxy = client_ip || forwarded_ips.last || remote_addrs.first
+
+        # Return first REMOTE_ADDR if there are no other options
+        not_proxy || ips_from('REMOTE_ADDR', :allow_proxies).first
       end
-    end
 
-    def initialize(app, check_ip_spoofing = true, trusted_proxies = nil)
-      @app = app
-      @check_ip_spoofing = check_ip_spoofing
-      regex = '(^127\.0\.0\.1$|^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.)'
-      regex << "|(#{trusted_proxies})" if trusted_proxies
-      @trusted_proxies = Regexp.new(regex, "i")
-    end
+      def to_s
+        return @ip if @calculated_ip
+        @calculated_ip = true
+        @ip = calculate_ip
+      end
 
-    def call(env)
-      env["action_dispatch.remote_ip"] = RemoteIpGetter.new(env, @check_ip_spoofing, @trusted_proxies)
-      @app.call(env)
+    protected
+
+      def ips_from(header, allow_proxies = false)
+        ips = @env[header] ? @env[header].strip.split(/[,\s]+/) : []
+        allow_proxies ? ips : ips.reject{|ip| ip =~ @middleware.proxies }
+      end
     end
+
   end
-end
+end

data/lib/action_dispatch/middleware/request_id.rb

@@ -0,0 +1,39 @@
+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
+  # 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.
+  #
+  # The unique request id can be used to trace a request end-to-end and would typically end up being part of log files
+  # from multiple pieces of the stack.
+  class RequestId
+    def initialize(app)
+      @app = app
+    end
+
+    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 ]
+    end
+
+    private
+      def external_request_id(env)
+        if request_id = env["HTTP_X_REQUEST_ID"].presence
+          request_id.gsub(/[^\w\-]/, "").first(255)
+        end
+      end
+
+      def internal_request_id
+        SecureRandom.hex(16)
+      end
+  end
+end

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

@@ -25,8 +25,6 @@ module ActionDispatch
     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
 
@@ -61,12 +59,12 @@ module ActionDispatch
             # 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"
+            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"
           end
           retry
-        elsif argument_error.message =~ %r{dump format error \(user class\)}
-          # Error unmarshalling object from session.
-          {}
         else
           raise
         end
@@ -76,16 +74,6 @@ module ActionDispatch
     class AbstractStore < Rack::Session::Abstract::ID
       include Compatibility
       include StaleSessionCheck
-
-      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
     end
   end
 end

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

@@ -0,0 +1,50 @@
+require 'action_dispatch/middleware/session/abstract_store'
+require 'rack/session/memcache'
+
+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.
+      def initialize(app, options = {})
+        @cache = options[:cache] || Rails.cache
+        options[:expire_after] ||= @cache.options[:expires_in]
+        super
+      end
+
+      # Get a session from the cache.
+      def get_session(env, sid)
+        sid ||= generate_sid
+        session = @cache.read(cache_key(sid))
+        session ||= {}
+        [sid, session]
+      end
+
+      # Set a session in the cache.
+      def set_session(env, sid, session, options)
+        key = cache_key(sid)
+        if session
+          @cache.write(key, session, :expires_in => options[:expire_after])
+        else
+          @cache.delete(key)
+        end
+        sid
+      end
+
+      # Remove a session from the cache.
+      def destroy_session(env, sid, options)
+        @cache.delete(cache_key(sid))
+        generate_sid
+      end
+
+      private
+        # Turn the session id into a cache key.
+        def cache_key(sid)
+          "_session_id:#{sid}"
+        end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ module ActionDispatch
       end
 
       def set_session(env, sid, session_data, options)
-        session_data.merge!("session_id" => sid)
+        session_data.merge("session_id" => sid)
       end
 
       def set_cookie(env, session_id, cookie)

data/lib/action_dispatch/middleware/show_exceptions.rb

@@ -1,171 +1,87 @@
-require 'active_support/core_ext/exception'
-require 'active_support/notifications'
 require 'action_dispatch/http/request'
+require 'action_dispatch/middleware/exception_wrapper'
+require 'active_support/deprecation'
 
 module ActionDispatch
-  # This middleware rescues any exception returned by the application and renders
-  # nice exception pages if it's being rescued locally.
+  # 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 parameter on initialization
+  # of ShowExceptions. Everytime 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.
+  # 
+  # 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.
   class ShowExceptions
-    RESCUES_TEMPLATE_PATH = File.join(File.dirname(__FILE__), 'templates')
-
-    cattr_accessor :rescue_responses
-    @@rescue_responses = Hash.new(:internal_server_error)
-    @@rescue_responses.update({
-      'ActionController::RoutingError'             => :not_found,
-      'AbstractController::ActionNotFound'         => :not_found,
-      'ActiveRecord::RecordNotFound'               => :not_found,
-      'ActiveRecord::StaleObjectError'             => :conflict,
-      'ActiveRecord::RecordInvalid'                => :unprocessable_entity,
-      'ActiveRecord::RecordNotSaved'               => :unprocessable_entity,
-      'ActionController::MethodNotAllowed'         => :method_not_allowed,
-      'ActionController::NotImplemented'           => :not_implemented,
-      'ActionController::InvalidAuthenticityToken' => :unprocessable_entity
-    })
-
-    cattr_accessor :rescue_templates
-    @@rescue_templates = Hash.new('diagnostics')
-    @@rescue_templates.update({
-      'ActionView::MissingTemplate'         => 'missing_template',
-      'ActionController::RoutingError'      => 'routing_error',
-      'AbstractController::ActionNotFound'  => 'unknown_action',
-      'ActionView::Template::Error'         => 'template_error'
-    })
-
     FAILSAFE_RESPONSE = [500, {'Content-Type' => 'text/html'},
       ["<html><body><h1>500 Internal Server Error</h1>" <<
        "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.</body></html>"]]
 
-    def initialize(app, consider_all_requests_local = false)
-      @app = app
-      @consider_all_requests_local = consider_all_requests_local
-    end
-
-    def call(env)
-      begin
-        status, headers, body = @app.call(env)
-        exception = nil
-
-        # Only this middleware cares about RoutingError. So, let's just raise
-        # it here.
-        if headers['X-Cascade'] == 'pass'
-           raise ActionController::RoutingError, "No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"
-        end
-      rescue Exception => exception
-        raise exception if env['action_dispatch.show_exceptions'] == false
-      end
-
-      exception ? render_exception(env, exception) : [status, headers, body]
-    end
-
-    private
-      def render_exception(env, exception)
-        log_error(exception)
-        exception = original_exception(exception)
-
-        request = Request.new(env)
-        if @consider_all_requests_local || request.local?
-          rescue_action_locally(request, exception)
-        else
-          rescue_action_in_public(exception)
-        end
-      rescue Exception => failsafe_error
-        $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
-        FAILSAFE_RESPONSE
-      end
-
-      # Render detailed diagnostics for unhandled exceptions rescued from
-      # a controller action.
-      def rescue_action_locally(request, exception)
-        template = ActionView::Base.new([RESCUES_TEMPLATE_PATH],
-          :request => request,
-          :exception => exception,
-          :application_trace => application_trace(exception),
-          :framework_trace => framework_trace(exception),
-          :full_trace => full_trace(exception)
-        )
-        file = "rescues/#{@@rescue_templates[exception.class.name]}.erb"
-        body = template.render(:file => file, :layout => 'rescues/layout.erb')
-        render(status_code(exception), body)
-      end
-
-      # Attempts to render a static error page based on the
-      # <tt>status_code</tt> thrown, or just return headers if no such file
-      # exists. At first, it will try to render a localized static page.
-      # For example, if a 500 error is being handled Rails and locale is :da,
-      # it will first attempt to render the file at <tt>public/500.da.html</tt>
-      # then attempt to render <tt>public/500.html</tt>. If none of them exist,
-      # the body of the response will be left empty.
-      def rescue_action_in_public(exception)
-        status = status_code(exception)
-        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))
-        else
-          render(status, '')
-        end
+    class << self
+      def rescue_responses
+        ActiveSupport::Deprecation.warn "ActionDispatch::ShowExceptions.rescue_responses is deprecated. " \
+          "Please configure your exceptions using a railtie or in your application config instead."
+        ExceptionWrapper.rescue_responses
       end
 
-      def status_code(exception)
-        Rack::Utils.status_code(@@rescue_responses[exception.class.name])
-      end
-
-      def render(status, body)
-        [status, {'Content-Type' => "text/html; charset=#{Response.default_charset}", 'Content-Length' => body.bytesize.to_s}, [body]]
+      def rescue_templates
+        ActiveSupport::Deprecation.warn "ActionDispatch::ShowExceptions.rescue_templates is deprecated. " \
+          "Please configure your exceptions using a railtie or in your application config instead."
+        ExceptionWrapper.rescue_templates
       end
+    end
 
-      def public_path
-        defined?(Rails.public_path) ? Rails.public_path : 'public_path'
+    def initialize(app, exceptions_app = nil)
+      if [true, false].include?(exceptions_app)
+        ActiveSupport::Deprecation.warn "Passing consider_all_requests_local option to ActionDispatch::ShowExceptions middleware no longer works"
+        exceptions_app = nil
       end
 
-      def log_error(exception)
-        return unless logger
-
-        ActiveSupport::Deprecation.silence do
-          message = "\n#{exception.class} (#{exception.message}):\n"
-          message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
-          message << "  " << application_trace(exception).join("\n  ")
-          logger.fatal("#{message}\n\n")
-        end
+      if exceptions_app.nil?
+        raise ArgumentError, "You need to pass an exceptions_app when initializing ActionDispatch::ShowExceptions. " \
+          "In case you want to render pages from a public path, you can use ActionDispatch::PublicExceptions.new('path/to/public')"
       end
 
-      def application_trace(exception)
-        clean_backtrace(exception, :silent)
-      end
+      @app = app
+      @exceptions_app = exceptions_app
+    end
 
-      def framework_trace(exception)
-        clean_backtrace(exception, :noise)
+    def call(env)
+      begin
+        response  = @app.call(env)
+      rescue Exception => exception
+        raise exception if env['action_dispatch.show_exceptions'] == false
       end
 
-      def full_trace(exception)
-        clean_backtrace(exception, :all)
-      end
+      response || render_exception(env, exception)
+    end
 
-      def clean_backtrace(exception, *args)
-        defined?(Rails) && Rails.respond_to?(:backtrace_cleaner) ?
-          Rails.backtrace_cleaner.clean(exception.backtrace, *args) :
-          exception.backtrace
-      end
+    private
 
-      def logger
-        defined?(Rails.logger) ? Rails.logger : Logger.new($stderr)
-      end
+    # Define this method because some plugins were monkey patching it.
+    # Remove this after 3.2 is out with the other deprecations in this class.
+    def status_code(*)
+    end
 
-    def original_exception(exception)
-      if registered_original_exception?(exception)
-        exception.original_exception
-      else
-        exception
-      end
+    def render_exception(env, exception)
+      wrapper = ExceptionWrapper.new(env, exception)
+      status  = wrapper.status_code
+      env["action_dispatch.exception"] = wrapper.exception
+      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
 
-    def registered_original_exception?(exception)
-      exception.respond_to?(:original_exception) && @@rescue_responses.has_key?(exception.original_exception.class.name)
+    def pass_response(status)
+      [status, {"Content-Type" => "text/html; charset=#{Response.default_charset}", "Content-Length" => "0"}, []]
     end
   end
 end