sunspot_rails_rbg 1.3.0

data/lib/sunspot/rails/configuration.rb

@@ -0,0 +1,322 @@
+require 'erb'
+
+module Sunspot #:nodoc:
+  module Rails #:nodoc:
+    #
+    # Sunspot::Rails is configured via the config/sunspot.yml file, which
+    # contains properties keyed by environment name. A sample sunspot.yml file
+    # would look like:
+    #
+    #   development:
+    #     solr:
+    #       hostname: localhost
+    #       port: 8982
+    #       min_memory: 512M
+    #       max_memory: 1G
+    #       solr_jar: /some/path/solr15/start.jar
+    #   test:
+    #     solr:
+    #       hostname: localhost
+    #       port: 8983
+    #       log_level: OFF
+    #   production:
+    #     solr:
+    #       hostname: localhost
+    #       port: 8983
+    #       path: /solr/myindex
+    #       log_level: WARNING
+    #       solr_home: /some/path
+    #     master_solr:
+    #       hostname: localhost
+    #       port: 8982
+    #       path: /solr
+    #     auto_commit_after_request: true
+    #
+    # Sunspot::Rails uses the configuration to set up the Solr connection, as
+    # well as for starting Solr with the appropriate port using the
+    # <code>rake sunspot:solr:start</code> task.
+    #
+    # If the <code>master_solr</code> configuration is present, Sunspot will use
+    # the Solr instance specified here for all write operations, and the Solr
+    # configured under <code>solr</code> for all read operations.
+    #
+    class Configuration
+      attr_writer :user_configuration
+      #
+      # The host name at which to connect to Solr. Default 'localhost'.
+      #
+      # ==== Returns
+      #
+      # String:: host name
+      #
+      def hostname
+        unless defined?(@hostname)
+          @hostname   = solr_url.host if solr_url
+          @hostname ||= user_configuration_from_key('solr', 'hostname')
+          @hostname ||= default_hostname
+        end
+        @hostname
+      end
+      
+      #
+      # The port at which to connect to Solr.
+      # Defaults to 8981 in test, 8982 in development and 8983 in production.
+      #
+      # ==== Returns
+      #
+      # Integer:: port
+      #
+      def port
+        unless defined?(@port)
+          @port   = solr_url.port if solr_url
+          @port ||= user_configuration_from_key('solr', 'port')
+          @port ||= default_port
+          @port   = @port.to_i
+        end
+        @port
+      end
+
+      #
+      # The url path to the Solr servlet (useful if you are running multicore).
+      # Default '/solr'.
+      #
+      # ==== Returns
+      #
+      # String:: path
+      #
+      def path
+        unless defined?(@path)
+          @path   = solr_url.path if solr_url
+          @path ||= user_configuration_from_key('solr', 'path')
+          @path ||= default_path
+        end
+        @path
+      end
+
+      #
+      # The host name at which to connect to the master Solr instance. Defaults
+      # to the 'hostname' configuration option.
+      #
+      # ==== Returns
+      #
+      # String:: host name
+      #
+      def master_hostname
+        @master_hostname ||= (user_configuration_from_key('master_solr', 'hostname') || hostname)
+      end
+
+      #
+      # The port at which to connect to the master Solr instance. Defaults to
+      # the 'port' configuration option.
+      #
+      # ==== Returns
+      #
+      # Integer:: port
+      #
+      def master_port
+        @master_port ||= (user_configuration_from_key('master_solr', 'port') || port).to_i
+      end
+
+      #
+      # The path to the master Solr servlet (useful if you are running multicore).
+      # Defaults to the value of the 'path' configuration option.
+      #
+      # ==== Returns
+      #
+      # String:: path
+      #
+      def master_path
+        @master_path ||= (user_configuration_from_key('master_solr', 'path') || path)
+      end
+
+      #
+      # True if there is a master Solr instance configured, otherwise false.
+      #
+      # ==== Returns
+      #
+      # Boolean:: bool
+      #
+      def has_master?
+        @has_master = !!user_configuration_from_key('master_solr')
+      end
+
+      # 
+      # The default log_level that should be passed to solr. You can
+      # change the individual log_levels in the solr admin interface.
+      # Default 'INFO'.
+      #
+      # ==== Returns
+      #
+      # String:: log_level
+      #
+      def log_level
+        @log_level ||= (user_configuration_from_key('solr', 'log_level') || 'INFO')
+      end
+      
+      #
+      # Should the solr index receive a commit after each http-request.
+      # Default true
+      #
+      # ==== Returns
+      # 
+      # Boolean: auto_commit_after_request?
+      #
+      def auto_commit_after_request?
+        @auto_commit_after_request ||= 
+          user_configuration_from_key('auto_commit_after_request') != false
+      end
+      
+      #
+      # As for #auto_commit_after_request? but only for deletes
+      # Default false
+      #
+      # ==== Returns
+      # 
+      # Boolean: auto_commit_after_delete_request?
+      #
+      def auto_commit_after_delete_request?
+        @auto_commit_after_delete_request ||= 
+          (user_configuration_from_key('auto_commit_after_delete_request') || false)
+      end
+      
+      
+      #
+      # The log directory for solr logfiles
+      #
+      # ==== Returns
+      # 
+      # String:: log_dir
+      #
+      def log_file
+        @log_file ||= (user_configuration_from_key('solr', 'log_file') || default_log_file_location )
+      end
+
+      def data_path
+        @data_path ||= user_configuration_from_key('solr', 'data_path') || File.join(::Rails.root, 'solr', 'data', ::Rails.env)
+      end
+      
+      def pid_path
+        @pids_path ||= user_configuration_from_key('solr', 'pid_path') || File.join(::Rails.root, 'solr', 'pids', ::Rails.env)
+      end
+      
+      # 
+      # The solr home directory. Sunspot::Rails expects this directory
+      # to contain a config, data and pids directory. See 
+      # Sunspot::Rails::Server.bootstrap for more information.
+      #
+      # ==== Returns
+      #
+      # String:: solr_home
+      #
+      def solr_home
+        @solr_home ||=
+          if user_configuration_from_key('solr', 'solr_home')
+            user_configuration_from_key('solr', 'solr_home')
+          else
+            File.join(::Rails.root, 'solr')
+          end
+      end
+
+      # 
+      # Solr start jar
+      #
+      def solr_jar
+        @solr_jar ||= user_configuration_from_key('solr', 'solr_jar')
+      end
+
+      # 
+      # Minimum java heap size for Solr instance
+      #
+      def min_memory
+        @min_memory ||= user_configuration_from_key('solr', 'min_memory')
+      end
+
+      # 
+      # Maximum java heap size for Solr instance
+      #
+      def max_memory
+        @max_memory ||= user_configuration_from_key('solr', 'max_memory')
+      end
+      
+      private
+      
+      #
+      # Logging in rails_root/log as solr_<environment>.log as a 
+      # default.
+      #
+      # ===== Returns
+      #
+      # String:: default_log_file_location
+      #
+      def default_log_file_location
+        File.join(::Rails.root, 'log', "solr_" + ::Rails.env + ".log")
+      end
+      
+      # 
+      # return a specific key from the user configuration in config/sunspot.yml
+      #
+      # ==== Returns
+      #
+      # Mixed:: requested_key or nil
+      #
+      def user_configuration_from_key( *keys )
+        keys.inject(user_configuration) do |hash, key|
+          hash[key] if hash
+        end
+      end
+      
+      #
+      # Memoized hash of configuration options for the current Rails environment
+      # as specified in config/sunspot.yml
+      #
+      # ==== Returns
+      #
+      # Hash:: configuration options for current environment
+      #
+      def user_configuration
+        @user_configuration ||=
+          begin
+            path = File.join(::Rails.root, 'config', 'sunspot.yml')
+            if File.exist?(path)
+              File.open(path) do |file|
+                processed = ERB.new(file.read).result
+                YAML.load(processed)[::Rails.env]
+              end
+            else
+              {}
+            end
+          end
+      end
+    
+    protected
+    
+      #
+      # When a specific hostname, port and path aren't provided in the
+      # sunspot.yml file, look for a key named 'url', then check the
+      # environment, then fall back to a sensible localhost default.
+      #
+      
+      def solr_url
+        if ENV['SOLR_URL'] || ENV['WEBSOLR_URL']
+          URI.parse(ENV['SOLR_URL'] || ENV['WEBSOLR_URL'])
+        end
+      end
+      
+      def default_hostname
+        'localhost'
+      end
+      
+      def default_port
+        { 'test'        => 8981,
+          'development' => 8982,
+          'production'  => 8983
+        }[::Rails.env]  || 8983
+      end
+      
+      def default_path
+        '/solr'
+      end
+      
+    end
+  end
+end

data/lib/sunspot/rails/init.rb

@@ -0,0 +1,5 @@
+Sunspot.session = Sunspot::Rails.build_session
+Sunspot::Adapters::InstanceAdapter.register(Sunspot::Rails::Adapters::ActiveRecordInstanceAdapter, ActiveRecord::Base)
+Sunspot::Adapters::DataAccessor.register(Sunspot::Rails::Adapters::ActiveRecordDataAccessor, ActiveRecord::Base)
+ActiveRecord::Base.module_eval { include(Sunspot::Rails::Searchable) }
+ActionController::Base.module_eval { include(Sunspot::Rails::RequestLifecycle) }

data/lib/sunspot/rails/log_subscriber.rb

@@ -0,0 +1,33 @@
+module Sunspot
+  module Rails
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def self.runtime=(value)
+        Thread.current["sorl_runtime"] = value
+      end
+
+      def self.runtime
+        Thread.current["sorl_runtime"] ||= 0
+      end
+
+      def self.reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+
+      def request(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        name = '%s (%.1fms)' % ["SOLR Request", event.duration]
+
+        # produces: path=/select parameters={fq: ["type:Tag"], q: rossi, fl: * score, qf: tag_name_text, defType: dismax, start: 0, rows: 20}
+        parameters = event.payload[:parameters].map { |k, v| "#{k}: #{color(v, BOLD, true)}" }.join(', ')
+        request = "path=#{event.payload[:path]} parameters={#{parameters}}"
+
+        debug "  #{color(name, GREEN, true)}  [ #{request} ]"
+      end
+    end
+  end
+end
+
+Sunspot::Rails::LogSubscriber.attach_to :rsolr

data/lib/sunspot/rails/railtie.rb

@@ -0,0 +1,36 @@
+module Sunspot
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer 'sunspot_rails.init' do
+        Sunspot.session = Sunspot::Rails.build_session
+        ActiveSupport.on_load(:active_record) do
+          Sunspot::Adapters::InstanceAdapter.register(Sunspot::Rails::Adapters::ActiveRecordInstanceAdapter, ActiveRecord::Base)
+          Sunspot::Adapters::DataAccessor.register(Sunspot::Rails::Adapters::ActiveRecordDataAccessor, ActiveRecord::Base)
+          include(Sunspot::Rails::Searchable)
+        end
+        ActiveSupport.on_load(:action_controller) do
+          include(Sunspot::Rails::RequestLifecycle)
+        end
+        require 'sunspot/rails/log_subscriber'
+        RSolr::Client.module_eval{ include Sunspot::Rails::SolrInstrumentation }
+      end
+
+      # Expose database runtime to controller for logging.
+      initializer "sunspot_rails.log_runtime" do |app|
+        require "sunspot/rails/railties/controller_runtime"
+        ActiveSupport.on_load(:action_controller) do
+          include Sunspot::Rails::Railties::ControllerRuntime
+        end
+      end
+
+      rake_tasks do
+        load 'sunspot/rails/tasks.rb'
+      end
+      
+      generators do
+        load "generators/sunspot_rails.rb"
+      end
+
+    end
+  end
+end

data/lib/sunspot/rails/railties/controller_runtime.rb

@@ -0,0 +1,36 @@
+module Sunspot
+  module Rails
+    module Railties
+      module ControllerRuntime
+        extend ActiveSupport::Concern
+
+        protected
+
+        attr_internal :solr_runtime
+
+        def cleanup_view_runtime
+          # TODO only if solr is connected? if not call to super
+
+          solr_rt_before_render = Sunspot::Rails::LogSubscriber.reset_runtime
+          runtime = super
+          solr_rt_after_render = Sunspot::Rails::LogSubscriber.reset_runtime
+          self.solr_runtime = solr_rt_before_render + solr_rt_after_render
+          runtime - solr_rt_after_render
+        end
+
+        def append_info_to_payload(payload)
+          super
+          payload[:solr_runtime] = solr_runtime
+        end
+
+        module ClassMethods
+          def log_process_action(payload)
+            messages, solr_runtime = super, payload[:solr_runtime]
+            messages << ("Solr: %.1fms" % solr_runtime.to_f) if solr_runtime
+            messages
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/rails/request_lifecycle.rb

@@ -0,0 +1,36 @@
+module Sunspot #:nodoc:
+  module Rails #:nodoc:
+    # 
+    # This module adds an after_filter to ActionController::Base that commits
+    # the Sunspot session if any documents have been added, changed, or removed
+    # in the course of the request.
+    #
+    module RequestLifecycle
+      class <<self
+        def included(base) #:nodoc:
+          subclasses = base.subclasses.map do |subclass|
+            begin
+              subclass.constantize
+            rescue NameError
+            end
+          end.compact
+          loaded_controllers = [base].concat(subclasses)
+          # Depending on how Sunspot::Rails is loaded, there may already be
+          # controllers loaded into memory that subclass this controller. In
+          # this case, since after_filter uses the inheritable_attribute
+          # structure, the already-loaded subclasses don't get the filters. So,
+          # the below ensures that all loaded controllers have the filter.
+          loaded_controllers.each do |controller|
+            controller.after_filter do
+              if Sunspot::Rails.configuration.auto_commit_after_request?
+                Sunspot.commit_if_dirty
+              elsif Sunspot::Rails.configuration.auto_commit_after_delete_request?
+                Sunspot.commit_if_delete_dirty
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end