jro_apps/redmine Commit - r13388:717f491f503d

Cache search result ids for faster search pagination (#18631)....

Jean-Philippe Lang -

r13388:717f491f503d

parent child

Context file:

r13388:717f491f503d

Collapse all files

app/controllers/search_controller.rb +1 -3

             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class SearchController < ApplicationController
               before_filter :find_optional_project
-              @@search_cache_store ||= ActiveSupport::Cache.lookup_store :memory_store
               def index
                 @question = params[:q] || ""
                 @question.strip!
                 @all_words = params[:all_words] ? params[:all_words].present? : true
                 @titles_only = params[:titles_only] ? params[:titles_only].present? : false
                 # quick jump to an issue
                 if (m = @question.match(/^#?(\d+)$/)) && (issue = Issue.visible.find_by_id(m[1].to_i))
                   redirect_to issue_path(issue)
                   return
                 end
                 projects_to_search =
                   case params[:scope]
                   when 'all'
                     nil
                   when 'my_projects'
                     User.current.projects
                   when 'subprojects'
                     @project ? (@project.self_and_descendants.active.to_a) : nil
                   else
                     @project
                   end
                 @object_types = Redmine::Search.available_search_types.dup
                 if projects_to_search.is_a? Project
                   # don't search projects
                   @object_types.delete('projects')
                   # only show what the user is allowed to view
                   @object_types = @object_types.select {|o| User.current.allowed_to?("view_#{o}".to_sym, projects_to_search)}
                 end
                 @scope = @object_types.select {|t| params[t]}
                 @scope = @object_types if @scope.empty?
                 fetcher = Redmine::Search::Fetcher.new(
                   @question, User.current, @scope, projects_to_search,
-                  :all_words => @all_words, :titles_only => @titles_only
+                  :all_words => @all_words, :titles_only => @titles_only, :cache => params[:page].present?
                 )
                 if fetcher.tokens.present?
                   @result_count = fetcher.result_count
                   @result_count_by_type = fetcher.result_count_by_type
                   @tokens = fetcher.tokens
                   @result_pages = Paginator.new @result_count, 10, params['page']
                   @results = fetcher.results(@result_pages.offset, @result_pages.per_page)
                 else
                   @question = ""
                 end
                 render :layout => false if request.xhr?
               end
             private
               def find_optional_project
                 return true unless params[:id]
                 @project = Project.find(params[:id])
                 check_project_privacy
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

config/application.rb +8 0

             require File.expand_path('../boot', __FILE__)
             require 'rails/all'
             Bundler.require(*Rails.groups)
             module RedmineApp
               class Application < Rails::Application
                 # Settings in config/environments/* take precedence over those specified here.
                 # Application configuration should go into files in config/initializers
                 # -- all .rb files in that directory are automatically loaded.
                 # Custom directories with classes and modules you want to be autoloadable.
                 config.autoload_paths += %W(#{config.root}/lib)
                 # Only load the plugins named here, in the order given (default is alphabetical).
                 # :all can be used as a placeholder for all plugins not explicitly named.
                 # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
                 config.active_record.store_full_sti_class = true
                 config.active_record.default_timezone = :local
                 # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
                 # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
                 # config.time_zone = 'Central Time (US & Canada)'
                 # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
                 # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
                 # config.i18n.default_locale = :de
                 I18n.enforce_available_locales = true
                 # Configure the default encoding used in templates for Ruby 1.9.
                 config.encoding = "utf-8"
                 # Configure sensitive parameters which will be filtered from the log file.
                 config.filter_parameters += [:password]
                 # Enable the asset pipeline
                 config.assets.enabled = false
                 # Version of your assets, change this if you want to expire all your assets
                 config.assets.version = '1.0'
                 config.action_mailer.perform_deliveries = false
                 # Do not include all helpers
                 config.action_controller.include_all_helpers = false
+                # Specific cache for search results, the default file store cache is not
+                # a good option as it could grow fast. A memory store (32MB max) is used
+                # as the default. If you're running multiple server processes, it's
+                # recommended to switch to a shared cache store (eg. mem_cache_store).
+                # See http://guides.rubyonrails.org/caching_with_rails.html#cache-stores
+                # for more options (same options as config.cache_store).
+                config.redmine_search_cache_store = :memory_store
                 config.session_store :cookie_store, :key => '_redmine_session'
                 if File.exists?(File.join(File.dirname(__FILE__), 'additional_environment.rb'))
                   instance_eval File.read(File.join(File.dirname(__FILE__), 'additional_environment.rb'))
                 end
               end
             end

lib/redmine/search.rb +37 -1

             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module Redmine
               module Search
                 mattr_accessor :available_search_types
                 @@available_search_types = []
                 class << self
                   def map(&block)
                     yield self
                   end
                   # Registers a search provider
                   def register(search_type, options={})
                     search_type = search_type.to_s
                     @@available_search_types << search_type unless @@available_search_types.include?(search_type)
                   end
+                  # Returns the cache store for search results
+                  # Can be configured with config.redmine_search_cache_store= in config/application.rb
+                  def cache_store
+                    @@cache_store ||= begin
+                      # if config.search_cache_store was not previously set, a no method error would be raised
+                      config = Rails.application.config.redmine_search_cache_store rescue :memory_store
+                      if config
+                        ActiveSupport::Cache.lookup_store config
+                      end
+                    end
+                  end
                 end
                 class Fetcher
                   attr_reader :tokens
                   def initialize(question, user, scope, projects, options={})
                     @user = user
                     @question = question.strip
                     @scope = scope
                     @projects = projects
+                    @cache = options.delete(:cache)
                     @options = options
                     # extract tokens from the question
                     # eg. hello "bye bye" => ["hello", "bye bye"]
                     @tokens = @question.scan(%r{((\s|^)"[\s\w]+"(\s|$)|\S+)}).collect {|m| m.first.gsub(%r{(^\s*"\s*|\s*"\s*$)}, '')}
                     # tokens must be at least 2 characters long
                     @tokens = @tokens.uniq.select {|w| w.length > 1 }
                     # no more than 5 tokens to search for
                     @tokens.slice! 5..-1
                   end
+                  # Returns the total result count
                   def result_count
                     result_ids.size
                   end
+                  # Returns the result count by type
                   def result_count_by_type
                     ret = Hash.new {|h,k| h[k] = 0}
                     result_ids.group_by(&:first).each do |scope, ids|
                       ret[scope] += ids.size
                     end
                     ret
                   end
+                  # Returns the results for the given offset and limit
                   def results(offset, limit)
                     result_ids_to_load = result_ids[offset, limit] || []
                     results_by_scope = Hash.new {|h,k| h[k] = []}
                     result_ids_to_load.group_by(&:first).each do |scope, scope_and_ids|
                       klass = scope.singularize.camelcase.constantize
                       results_by_scope[scope] += klass.search_results_from_ids(scope_and_ids.map(&:last))
                     end
                     result_ids_to_load.map do |scope, id|
                       results_by_scope[scope].detect {|record| record.id == id}
                     end.compact
                   end
+                  # Returns the results ids, sorted by rank
                   def result_ids
-                    @ranks_and_ids ||= load_result_ids
+                    @ranks_and_ids ||= load_result_ids_from_cache
                   end
                   private
+                  def project_ids
+                    Array.wrap(@projects).map(&:id)
+                  end
+                  def load_result_ids_from_cache
+                    if Redmine::Search.cache_store
+                      cache_key = ActiveSupport::Cache.expand_cache_key(
+                        [@question, @user.id, @scope.sort, @options, project_ids.sort]
+                      )
+                      Redmine::Search.cache_store.fetch(cache_key, :force => !@cache) do
+                        load_result_ids
+                      end
+                    else
+                      load_result_ids
+                    end
+                  end
                   def load_result_ids
                     ret = []
                     # get all the results ranks and ids
                     @scope.each do |scope|
                       klass = scope.singularize.camelcase.constantize
                       ranks_and_ids_in_scope = klass.search_result_ranks_and_ids(@tokens, User.current, @projects, @options)
                       # converts timestamps to integers for faster sort
                       ret += ranks_and_ids_in_scope.map {|rank, id| [scope, [rank.to_i, id]]}
                     end
                     # sort results, higher rank and id first
                     ret.sort! {|a,b| b.last <=> a.last}
+                    # only keep ids now that results are sorted
                     ret.map! {|scope, r| [scope, r.last]}
                     ret
                   end
                 end
                 module Controller
                   def self.included(base)
                     base.extend(ClassMethods)
                   end
                   module ClassMethods
                     @@default_search_scopes = Hash.new {|hash, key| hash[key] = {:default => nil, :actions => {}}}
                     mattr_accessor :default_search_scopes
                     # Set the default search scope for a controller or specific actions
                     # Examples:
                     #   * search_scope :issues # => sets the search scope to :issues for the whole controller
                     #   * search_scope :issues, :only => :index
                     #   * search_scope :issues, :only => [:index, :show]
                     def default_search_scope(id, options = {})
                       if actions = options[:only]
                         actions = [] << actions unless actions.is_a?(Array)
                         actions.each {|a| default_search_scopes[controller_name.to_sym][:actions][a.to_sym] = id.to_s}
                       else
                         default_search_scopes[controller_name.to_sym][:default] = id.to_s
                       end
                     end
                   end
                   def default_search_scopes
                     self.class.default_search_scopes
                   end
                   # Returns the default search scope according to the current action
                   def default_search_scope
                     @default_search_scope ||= default_search_scopes[controller_name.to_sym][:actions][action_name.to_sym] ||
                                               default_search_scopes[controller_name.to_sym][:default]
                   end
                 end
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages