sunspot_solr 2.0.0.pre.120720 → 2.0.0.pre.120924

data/sunspot_rails/lib/sunspot/rails/server.rb

@@ -0,0 +1,106 @@
+module Sunspot
+  module Rails
+    class Server < Sunspot::Solr::Server
+      # ActiveSupport log levels are integers; this array maps them to the
+      # appropriate java.util.logging.Level constant
+      LOG_LEVELS = %w(FINE INFO WARNING SEVERE SEVERE INFO)
+
+      # 
+      # Directory in which to store PID files
+      #
+      def pid_dir
+        configuration.pid_dir || File.join(::Rails.root, 'tmp', 'pids')
+      end
+
+      # 
+      # Name of the PID file
+      #
+      def pid_file
+        "sunspot-solr-#{::Rails.env}.pid"
+      end
+
+      # 
+      # Directory to store lucene index data files
+      #
+      # ==== Returns
+      #
+      # String:: data_path
+      #
+      def solr_data_dir
+        configuration.data_path
+      end
+
+      # 
+      # Directory to use for Solr home.
+      #
+      def solr_home
+        File.join(configuration.solr_home)
+      end
+
+      #
+      # Solr start jar
+      #
+      def solr_jar
+        configuration.solr_jar || super
+      end
+
+      # 
+      # Address on which to run Solr
+      #
+      def bind_address
+        configuration.bind_address
+      end
+
+      # 
+      # Port on which to run Solr
+      #
+      def port
+        configuration.port
+      end
+
+      #
+      # Severity level for logging. This is based on the severity level for the
+      # Rails logger.
+      #
+      def log_level
+        LOG_LEVELS[::Rails.logger.level]
+      end
+
+      # 
+      # Log file for Solr. File is in the rails log/ directory.
+      #
+      def log_file
+        File.join(::Rails.root, 'log', "sunspot-solr-#{::Rails.env}.log")
+      end
+
+      # 
+      # Minimum Java heap size for Solr
+      #
+      def min_memory
+        configuration.min_memory
+      end
+
+      # 
+      # Maximum Java heap size for Solr
+      #
+      def max_memory
+        configuration.max_memory
+      end
+
+      private
+
+      #
+      # access to the Sunspot::Rails::Configuration, defined in
+      # sunspot.yml. Use Sunspot::Rails.configuration if you want
+      # to access the configuration directly.
+      #
+      # ==== returns
+      #
+      # Sunspot::Rails::Configuration:: configuration
+      #
+      def configuration
+        Sunspot::Rails.configuration
+      end
+    end
+  end
+end

data/sunspot_rails/lib/sunspot/rails/solr_instrumentation.rb

@@ -0,0 +1,19 @@
+module Sunspot
+  module Rails
+    module SolrInstrumentation
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :execute, :as_instrumentation
+      end
+
+
+      def execute_with_as_instrumentation(path, params={}, *extra)
+        ActiveSupport::Notifications.instrument("request.rsolr",
+                                                {:path => path, :parameters => params}) do
+          execute_without_as_instrumentation(path, params, *extra)
+        end
+      end
+    end
+  end
+end

data/sunspot_rails/lib/sunspot/rails/solr_logging.rb

@@ -0,0 +1,62 @@
+module Sunspot
+  module Rails
+    module SolrLogging
+
+      class <<self
+        def included(base)
+          base.alias_method_chain :execute, :rails_logging
+        end
+      end
+
+      COMMIT = %r{<commit/>}
+
+      def execute_with_rails_logging(client, request_context)
+        body = (request_context[:data]||"").dup
+        action = request_context[:path].capitalize
+        if body =~ COMMIT
+          action = "Commit"
+          body = ""
+        end
+        body = body[0, 800] + '...' if body.length > 800
+
+        # Make request and log.
+        response = nil
+        begin
+          ms = Benchmark.ms do
+            response = execute_without_rails_logging(client, request_context)
+          end
+          log_name = 'Solr %s (%.1fms)' % [action, ms]
+          ::Rails.logger.debug(format_log_entry(log_name, body))
+        rescue Exception => e
+          log_name = 'Solr %s (Error)' % [action]
+          ::Rails.logger.error(format_log_entry(log_name, body))
+          raise e
+        end
+
+        response
+      end
+
+      private
+
+      def format_log_entry(message, dump = nil)
+        @colorize_logging ||= begin
+          ::Rails.application.config.colorize_logging # Rails 3
+        rescue NoMethodError
+          ActiveRecord::Base.colorize_logging # Rails 2
+        end
+        if @colorize_logging
+          message_color, dump_color = "4;32;1", "0;1"
+          log_entry = "  \e[#{message_color}m#{message}\e[0m   "
+          log_entry << "\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\e[0m" % dump if dump
+          log_entry
+        else
+          "%s  %s" % [message, dump]
+        end
+      end
+    end
+  end
+end
+
+RSolr::Connection.module_eval do
+  include Sunspot::Rails::SolrLogging
+end

data/sunspot_rails/lib/sunspot/rails/spec_helper.rb

@@ -0,0 +1,26 @@
+module Sunspot
+  module Rails
+    module SpecHelper
+      def disconnect_sunspot
+        before(:each) do
+          Sunspot.session = StubSessionProxy.new(Sunspot.session)
+        end
+
+        after(:each) do
+          Sunspot.session = Sunspot.session.original_session
+        end
+      end
+    end
+  end
+end
+
+rspec =
+  begin
+    RSpec
+  rescue NameError, ArgumentError
+    Spec::Runner
+  end
+
+rspec.configure do |config|
+  config.extend(Sunspot::Rails::SpecHelper)
+end

data/sunspot_rails/lib/sunspot/rails/stub_session_proxy.rb

@@ -0,0 +1,146 @@
+module Sunspot
+  module Rails
+    class StubSessionProxy
+      attr_reader :original_session
+
+      def initialize(original_session)
+        @original_session = original_session
+      end
+
+      def index(*objects)
+      end
+
+      def index!(*objects)
+      end
+
+      def remove(*objects)
+      end
+
+      def remove!(*objects)
+      end
+
+      def remove_by_id(clazz, id)
+      end
+
+      def remove_by_id!(clazz, id)
+      end
+
+      def remove_all(clazz = nil)
+      end
+
+      def remove_all!(clazz = nil)
+      end
+
+      def dirty?
+        false
+      end
+
+      def delete_dirty?
+        false
+      end
+
+      def commit_if_dirty
+      end
+
+      def commit_if_delete_dirty
+      end
+
+      def commit
+      end
+
+      def search(*types)
+        Search.new
+      end
+
+      def new_search(*types)
+        Search.new
+      end
+
+      def more_like_this(*args)
+        Search.new
+      end
+
+      def new_more_like_this(*args)
+        Search.new
+      end
+
+      class Search
+        
+        def build
+          self
+        end
+
+        def results
+          PaginatedCollection.new
+        end
+
+        def hits(options = {})
+          PaginatedCollection.new
+        end
+
+        def total
+          0
+        end
+
+        def facet(name)
+        end
+
+        def dynamic_facet(name)
+        end
+
+        def execute
+          self
+        end
+      end
+      
+      
+      class PaginatedCollection < Array
+        
+        def total_count
+          0
+        end
+        alias :total_entries :total_count
+        
+        def current_page
+          1
+        end
+        
+        def per_page
+          30
+        end
+        alias :limit_value :per_page
+        
+        def total_pages
+          1
+        end
+        alias :num_pages :total_pages
+
+        def first_page?
+          true
+        end
+
+        def last_page?
+          true
+        end
+
+        def previous_page
+          nil
+        end
+
+        def next_page
+          nil
+        end
+
+        def out_of_bounds?
+          false
+        end
+
+        def offset
+          0
+        end
+        
+      end
+      
+    end
+  end
+end

data/sunspot_rails/lib/sunspot/rails/tasks.rb

@@ -0,0 +1,94 @@
+namespace :sunspot do
+
+  desc "Reindex all solr models that are located in your application's models directory."
+  # This task depends on the standard Rails file naming \
+  # conventions, in that the file name matches the defined class name. \
+  # By default the indexing system works in batches of 50 records, you can \
+  # set your own value for this by using the batch_size argument. You can \
+  # also optionally define a list of models to separated by a forward slash '/'
+  # 
+  # $ rake sunspot:reindex                # reindex all models
+  # $ rake sunspot:reindex[1000]          # reindex in batches of 1000
+  # $ rake sunspot:reindex[false]         # reindex without batching
+  # $ rake sunspot:reindex[,Post]         # reindex only the Post model
+  # $ rake sunspot:reindex[1000,Post]     # reindex only the Post model in
+  #                                       # batchs of 1000
+  # $ rake sunspot:reindex[,Post+Author]  # reindex Post and Author model
+  task :reindex, [:batch_size, :models] => [:environment] do |t, args|
+
+    # Retry once or gracefully fail for a 5xx error so we don't break reindexing
+    Sunspot.session = Sunspot::SessionProxy::Retry5xxSessionProxy.new(Sunspot.session)
+
+    # Set up general options for reindexing
+    reindex_options = { :batch_commit => false }
+    
+    case args[:batch_size]
+    when 'false'
+      reindex_options[:batch_size] = nil
+    when /^\d+$/ 
+      reindex_options[:batch_size] = args[:batch_size].to_i if args[:batch_size].to_i > 0
+    end
+
+    # Load all the application's models. Models which invoke 'searchable' will register themselves
+    # in Sunspot.searchable.
+    Dir.glob(Rails.root.join('app/models/**/*.rb')).each { |path| require path }
+
+    # By default, reindex all searchable models
+    sunspot_models = Sunspot.searchable
+
+    # Choose a specific subset of models, if requested
+    if args[:models]
+      model_names = args[:models].split('+')
+      sunspot_models = model_names.map{ |m| m.constantize }
+    end
+    
+    # Set up progress_bar to, ah, report progress
+    begin
+      require 'progress_bar'
+      total_documents = sunspot_models.map { | m | m.count }.sum
+      reindex_options[:progress_bar] = ProgressBar.new(total_documents)
+    rescue LoadError => e
+      $stdout.puts "Skipping progress bar: for progress reporting, add gem 'progress_bar' to your Gemfile"
+    rescue Exception => e
+      $stderr.puts "Error using progress bar: #{e.message}"
+    end
+
+    # Finally, invoke the class-level solr_reindex on each model
+    sunspot_models.each do |model|
+      model.solr_reindex(reindex_options)
+    end
+  end
+
+  def sunspot_solr_in_load_path?
+    # http://www.rubular.com/r/rJGDh7eOSc
+    $:.any? { |path| path =~ %r{sunspot_solr(-[^/]+)?/lib$} }
+  end
+
+  unless sunspot_solr_in_load_path?
+    namespace :solr do
+      task :moved_to_sunspot_solr do
+        abort %(
+  Note: This task has been moved to the sunspot_solr gem. To install, start and
+  stop a local Solr instance, please add sunspot_solr to your Gemfile:
+
+  group :development do
+    gem 'sunspot_solr'
+  end
+
+)
+      end
+
+      desc 'Start the Solr instance'
+      task :start => :moved_to_sunspot_solr
+
+      desc 'Run the Solr instance in the foreground'
+      task :run => :moved_to_sunspot_solr
+
+      desc 'Stop the Solr instance'
+      task :stop => :moved_to_sunspot_solr
+
+      # for backwards compatibility
+      task :reindex => :"sunspot:reindex"
+    end
+  end
+end