sunspot 0.10.9 → 1.0.0

data/lib/sunspot/server.rb

@@ -0,0 +1,148 @@
+require 'escape'
+require 'set'
+require 'tempfile'
+
+module Sunspot #:nodoc:
+  class Server
+    # Raised if #stop is called but the server is not running
+    ServerError = Class.new(RuntimeError)
+    AlreadyRunningError = Class.new(ServerError)
+    NotRunningError = Class.new(ServerError)
+
+    # Name of the sunspot executable (shell script)
+    SOLR_START_JAR = File.expand_path(
+      File.join(File.dirname(__FILE__), '..', '..', 'solr', 'start.jar')
+    )
+
+    LOG_LEVELS = Set['SEVERE', 'WARNING', 'INFO', 'CONFIG', 'FINE', 'FINER', 'FINEST']
+
+    attr_accessor :min_memory, :max_memory, :port, :solr_data_dir, :solr_home, :log_file
+    attr_writer :pid_dir, :pid_file, :log_level, :solr_data_dir, :solr_home
+
+    #
+    # Start the sunspot-solr server. Bootstrap solr_home first,
+    # if neccessary.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def start
+      if File.exist?(pid_path)
+        existing_pid = IO.read(pid_path).to_i
+        begin
+          Process.kill(0, existing_pid)
+          raise(AlreadyRunningError, "Server is already running with PID #{existing_pid}")
+        rescue Errno::ESRCH
+          STDERR.puts("Removing stale PID file at #{pid_path}")
+          FileUtils.rm(pid_path)
+        end
+      end
+      fork do
+        pid = fork do
+          Process.setsid
+          STDIN.reopen('/dev/null')
+          STDOUT.reopen('/dev/null', 'a')
+          STDERR.reopen(STDOUT)
+          run
+        end
+        FileUtils.mkdir_p(pid_dir)
+        File.open(pid_path, 'w') do |file|
+          file << pid
+        end
+      end
+    end
+
+    # 
+    # Run the sunspot-solr server in the foreground. Boostrap
+    # solr_home first, if neccessary.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def run
+      command = ['java']
+      command << "-Xms#{min_memory}" if min_memory
+      command << "-Xmx#{max_memory}" if max_memory
+      command << "-Djetty.port=#{port}" if port
+      command << "-Dsolr.data.dir=#{solr_data_dir}" if solr_data_dir
+      command << "-Dsolr.solr.home=#{solr_home}" if solr_home
+      command << "-Djava.util.logging.config.file=#{logging_config_path}" if logging_config_path
+      command << '-jar' << File.basename(SOLR_START_JAR)
+      FileUtils.cd(File.dirname(SOLR_START_JAR)) do
+        exec(Escape.shell_command(command))
+      end
+    end
+
+    # 
+    # Stop the sunspot-solr server.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def stop
+      if File.exist?(pid_path)
+        pid = IO.read(pid_path).to_i
+        begin
+          Process.kill('TERM', pid)
+        rescue Errno::ESRCH
+          raise NotRunningError, "Process with PID #{pid} is no longer running"
+        ensure
+          FileUtils.rm(pid_path)
+        end
+      else
+        raise NotRunningError, "No PID file at #{pid_path}"
+      end
+    end
+
+    def log_level=(level)
+      unless LOG_LEVELS.include?(level.to_s.upcase)
+        raise(ArgumentError, "#{level} is not a valid log level: Use one of #{LOG_LEVELS.to_a.join(',')}")
+      end
+      @log_level = level.to_s.upcase
+    end
+
+    def log_level
+      @log_level || 'WARNING'
+    end
+
+    def pid_path
+      File.join(pid_dir, pid_file)
+    end
+
+    def pid_file
+      @pid_file || 'sunspot-solr.pid'
+    end
+
+    def pid_dir
+      File.expand_path(@pid_dir || FileUtils.pwd)
+    end
+
+    def solr_data_dir
+      File.expand_path(@solr_data_dir || Dir.tmpdir)
+    end
+
+    def solr_home
+      File.expand_path(@solr_home || File.join(File.dirname(SOLR_START_JAR), 'solr'))
+    end
+
+    private
+
+    def logging_config_path
+      return @logging_config_path if defined?(@logging_config_path)
+      @logging_config_path =
+        if log_file
+          logging_config = Tempfile.new('logging.properties')
+          logging_config.puts("handlers = java.util.logging.FileHandler")
+          logging_config.puts("java.util.logging.FileHandler.level = #{log_level.to_s.upcase}")
+          logging_config.puts("java.util.logging.FileHandler.pattern = #{log_file}")
+          logging_config.puts("java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter")
+          logging_config.flush
+          logging_config.close
+          logging_config.path
+        end
+    end
+  end
+end

data/lib/sunspot/session.rb

@@ -29,37 +29,28 @@ module Sunspot
     # connection. Usually you will want to stick with the default arguments
     # when instantiating your own sessions.
     #
-    def initialize(config = Configuration.build, connection = nil, master_connection = nil)
+    def initialize(config = Configuration.build, connection = nil)
       @config = config
       yield(@config) if block_given?
       @connection = connection
-      @master_connection = master_connection
       @deletes = @adds = 0
     end
 
     # 
     # See Sunspot.new_search
     #
-    def new_search(*types)
+    def new_search(*types, &block)
       types.flatten!
-      if types.empty?
-        raise(ArgumentError, "You must specify at least one type to search")
-      end
-      setup =
-        if types.length == 1
-          Setup.for(types.first)
-        else
-          CompositeSetup.for(types)
-          end
-      Search.new(connection, setup, Query::Query.new(types), @config)
+      search = Search.new(connection, setup_for_types(types), Query::Query.new(types), @config)
+      search.build(&block) if block
+      search
     end
 
     #
     # See Sunspot.search
     #
     def search(*types, &block)
-      search = new_search(*types)
-      search.build(&block) if block
+      search = new_search(*types, &block)
       search.execute!
     end
 
@@ -85,17 +76,30 @@ module Sunspot
     #
     def commit
       @adds = @deletes = 0
-      master_connection.commit
+      connection.commit
     end
 
     # 
     # See Sunspot.remove
     #
-    def remove(*objects)
-      objects.flatten!
-      @deletes += objects.length
-      objects.each do |object|
-        indexer.remove(object)
+    def remove(*objects, &block)
+      if block
+        types = objects
+        conjunction = Query::Connective::Conjunction.new
+        if types.length == 1
+          conjunction.add_restriction(TypeField.instance, Query::Restriction::EqualTo, types.first)
+        else
+          conjunction.add_restriction(TypeField.instance, Query::Restriction::AnyOf, types)
+        end
+        dsl = DSL::Scope.new(conjunction, setup_for_types(types))
+        Util.instance_eval_or_call(dsl, &block)
+        indexer.remove_by_scope(conjunction)
+      else
+        objects.flatten!
+        @deletes += objects.length
+        objects.each do |object|
+          indexer.remove(object)
+        end
       end
     end
 
@@ -135,7 +139,7 @@ module Sunspot
       classes.flatten!
       if classes.empty?
         @deletes += 1
-        Indexer.remove_all(master_connection)
+        indexer.remove_all
       else
         @deletes += classes.length
         classes.each { |clazz| indexer.remove_all(clazz) }
@@ -195,42 +199,26 @@ module Sunspot
     #
     # ==== Returns
     #
-    # Solr::Connection:: The connection for this session
+    # RSolr::Connection::Base:: The connection for this session
     #
     def connection
       @connection ||=
-        begin
-          connection = self.class.connection_class.connect(
-            :url => config.solr.url
-          )
-          connection
-        end
+        self.class.connection_class.connect(:url => config.solr.url)
     end
 
-    # 
-    # Retrieve the Solr connection to the master for this session, creating one
-    # if it does not already exist.
-    #
-    # ==== Returns
-    #
-    # Solr::Connection:: The connection for this session
-    #
-    def master_connection
-      @master_connection ||=
-        begin
-          if config.master_solr.url && config.master_solr.url != config.solr.url
-            master_connection = self.class.connection_class.new(
-              RSolr::Connection::NetHttp.new(:url => config.master_solr.url)
-            )
-            master_connection
-          else
-            connection
-          end
-        end
+    def indexer
+      @indexer ||= Indexer.new(connection)
     end
 
-    def indexer
-      @indexer ||= Indexer.new(master_connection)
+    def setup_for_types(types)
+      if types.empty?
+        raise(ArgumentError, "You must specify at least one type to search")
+      end
+      if types.length == 1
+        Setup.for(types.first)
+      else
+        CompositeSetup.for(types)
+      end
     end
   end
 end

data/lib/sunspot/session_proxy/abstract_session_proxy.rb

@@ -0,0 +1,29 @@
+module Sunspot
+  module SessionProxy
+    class AbstractSessionProxy #:nodoc:
+      class <<self
+        def delegate(*args)
+          options = Util.extract_options_from(args)
+          delegate = options[:to]
+          args.each do |method|
+            module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              def #{method}(*args, &block)
+                #{delegate}.#{method}(*args, &block)
+              end
+            RUBY
+          end
+        end
+
+        def not_supported(*methods)
+          methods.each do |method|
+            module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              def #{method}(*args, &block)
+                raise NotSupportedError, "#{name} does not support #{method.inspect}"
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/session_proxy/class_sharding_session_proxy.rb

@@ -0,0 +1,66 @@
+module Sunspot
+  module SessionProxy
+    # 
+    # An abstract subclass of ShardingSessionProxy that shards by class.
+    # Concrete subclasses should not override the #session_for method, but
+    # should instead implement the #session_for_class method. They must also
+    # still implement the #all_sessions method.
+    #
+    # Unlike its parent class, ClassShardingSessionProxy implements
+    # #remove_by_id and all flavors of #remove_all.
+    #
+    class ClassShardingSessionProxy < ShardingSessionProxy
+      # 
+      # Remove the Session object pointing at the shard that indexes the given
+      # class.
+      #
+      # <strong>Concrete subclasses must implement this method.</strong>
+      #
+      def session_for_class(clazz)
+        raise NotImplementedError
+      end
+
+      # 
+      # See Sunspot.remove_by_id
+      #
+      def remove_by_id(clazz, id)
+        session_for_class(clazz).remove_by_id(clazz, id)
+      end
+
+      # 
+      # See Sunspot.remove_by_id!
+      #
+      def remove_by_id!(clazz, id)
+        session_for_class(clazz).remove_by_id!(clazz, id)
+      end
+
+      # 
+      # See Sunspot.remove_all
+      #
+      def remove_all(clazz = nil)
+        if clazz
+          session_for_class(clazz).remove_all(clazz)
+        else
+          all_sessions.each { |session| session.remove_all }
+        end
+      end
+
+      # 
+      # See Sunspot.remove_all!
+      #
+      def remove_all!(clazz = nil)
+        if clazz
+          session_for_class(clazz).remove_all!(clazz)
+        else
+          all_sessions.each { |session| session.remove_all! }
+        end
+      end
+
+      private
+
+      def session_for(object)
+        session_for_class(object.class)
+      end
+    end
+  end
+end

data/lib/sunspot/session_proxy/id_sharding_session_proxy.rb

@@ -0,0 +1,89 @@
+module Sunspot
+  module SessionProxy
+    # 
+    # A concrete implementation of ShardingSessionProxy that determines the
+    # shard for a given object based on the hash of its class and ID.
+    #
+    # <strong>If you change the number of shard sessions that this proxy
+    # encapsulates, all objects will point to a different shard.</strong> If you
+    # plan on adding more shards over time, consider your own
+    # ShardingSessionProxy implementation that does not determine the session
+    # using modular arithmetic (e.g., IDs 1-10000 go to shard 1, 10001-20000 go
+    # to shard 2, etc.)
+    #
+    # This implementation will, on average, yield an even distribution of
+    # objects across shards.
+    #
+    # Unlike the abstract ShardingSessionProxy, this proxy supports the
+    # #remove_by_id method.
+    #
+    class IdShardingSessionProxy < ShardingSessionProxy
+      #
+      # The shard sessions encapsulated by this class.
+      #
+      attr_reader :sessions
+      alias_method :all_sessions, :sessions #:nodoc:
+
+      # 
+      # Initialize with a search session (see ShardingSessionProxy.new) and a
+      # collection of one or more shard sessions. See note about changing the
+      # number of shard sessions in the documentation for this class.
+      #
+      def initialize(search_session, shard_sessions)
+        super(search_session)
+        @sessions = shard_sessions
+      end
+
+      # 
+      # Return a session based on the hash of the class and ID, modulo the
+      # number of shard sessions.
+      #
+      def session_for(object) #:nodoc:
+        session_for_index_id(Adapters::InstanceAdapter.adapt(object).index_id)
+      end
+
+      # 
+      # See Sunspot.remove_by_id
+      #
+      def remove_by_id(clazz, id)
+        session_for_index_id(
+          Adapters::InstanceAdapter.index_id_for(clazz, id)
+        ).remove_by_id(clazz, id)
+      end
+
+      # 
+      # See Sunspot.remove_by_id!
+      #
+      def remove_by_id!(clazz, id)
+        session_for_index_id(
+          Adapters::InstanceAdapter.index_id_for(clazz, id)
+        ).remove_by_id!(clazz, id)
+      end
+
+      private
+
+      def session_for_index_id(index_id)
+        @sessions[id_hash(index_id) % @sessions.length]
+      end
+
+      # 
+      # This method is implemented explicitly instead of using String#hash to
+      # give predictable behavior across different Ruby interpreters.
+      #
+      if "".respond_to?(:bytes) # Ruby 1.9
+        def id_hash(id)
+          id.bytes.inject { |hash, byte| hash * 31 + byte }
+        end
+      else
+        def id_hash(id)
+          hash, i, len = 0, 0, id.length
+          while i < len
+            hash = hash * 31 + id[i]
+            i += 1
+          end
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/session_proxy/master_slave_session_proxy.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), 'abstract_session_proxy')
+
+module Sunspot
+  module SessionProxy
+    # 
+    # This session proxy implementation allows Sunspot to be used with a
+    # master/slave Solr deployment. All write methods are delegated to a master
+    # session, and read methods are delegated to a slave session.
+    #
+    class MasterSlaveSessionProxy < AbstractSessionProxy
+      #
+      # The session that connects to the master Solr instance.
+      #
+      attr_reader :master_session
+      # 
+      # The session that connects to the slave Solr instance.
+      #
+      attr_reader :slave_session
+
+      delegate :batch, :commit, :commit_if_delete_dirty, :commit_if_dirty,
+               :config, :delete_dirty?, :dirty?, :index, :index!, :remove,
+               :remove!, :remove_all, :remove_all!, :remove_by_id,
+               :remove_by_id!, :to => :master_session
+      delegate :new_search, :search, :to => :slave_session
+
+      def initialize(master_session, slave_session)
+        @master_session, @slave_session = master_session, slave_session
+      end
+
+      # 
+      # By default, return the configuration for the master session. If the
+      # +delegate+ param is +:slave+, then return config for the slave session.
+      #
+      def config(delegate = :master)
+        case delegate
+        when :master then @master_session.config
+        when :slave then  @slave_session.config
+        else raise(ArgumentError, "Expected :master or :slave")
+        end
+      end
+    end
+  end
+end