gojee-sunspot 2.0.2 → 2.0.3

data/lib/sunspot/session_proxy/abstract_session_proxy.rb

@@ -1,29 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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!, :optimize, :remove,
-               :remove!, :remove_all, :remove_all!, :remove_by_id,
-               :remove_by_id!, :to => :master_session
-      delegate :new_search, :search, :new_more_like_this, :more_like_this, :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

data/lib/sunspot/session_proxy/multicore_session_proxy.rb

@@ -1,67 +0,0 @@
-module Sunspot
-  module SessionProxy
-    class MulticoreSessionProxy < AbstractSessionProxy
-
-      def initialize( cores )
-        @sessions = {}
-        @cores ||= []
-        ( @cores << cores ).flatten!
-        cores.each do |core|
-
-          # can't find a better way grab the sunspot.yml configuration (:user_configuration is a private method)
-          modified_config = Marshal.load( Marshal.dump( Sunspot::Rails.configuration.send(:user_configuration) ) )
-
-          modified_config["solr"]["path"] = File.join(
-            ( modified_config["solr"]["path"] || Sunspot::Rails.configuration.path ), core )
-            
-          extended_config = Sunspot::Rails::ExtendedConfiguration.new(modified_config)
-          session = @sessions[core] = Sunspot::Rails.build_session(extended_config)
-        end
-      end
-
-      attr_accessor :selected_session
-        
-      def method_missing(method, *args, &block)
-        inspectable_args = args.flatten
-        types = inspectable_args.select(&:searchable?) rescue []
-        types += inspectable_args.select{|a| a.class.searchable? rescue false }
-        
-        self.selected_session = session_for_types(types) || self.selected_session
-        
-        if self.selected_session.respond_to?(method)
-          begin
-            self.selected_session.send(method, *args, &block) 
-          rescue Exception => e
-            (puts "method #{method} caused: #{e.message}")
-          end
-        else
-          # raise NoMethodError, "Method #{method} isn't defined on session"
-          # logger.info("do nothing")
-          # super
-          # self.selected_session.send(method, *args, &block)
-          return false
-        end
-      end
-      
-      protected
-        def infer_configuration_options_from_env_url( options )
-          if ENV["SOLR_URL"]
-            
-          end
-        end
-        
-        def session_for_types(*types)
-          cores = types.flatten.map{|t| t.sunspot_options[:core] }.uniq
-          raise ArgumentError, "Can't mix and match types that use different solr cores" if cores.length > 1
-
-          @sessions[cores.first]
-        end
-        
-        def session_for_objects(*objects)
-          types = objects.map(&:class).uniq
-          session_for_types(types)
-        end
-
-    end
-  end
-end

data/lib/sunspot/session_proxy/sharding_session_proxy.rb

@@ -1,222 +0,0 @@
-require File.join(File.dirname(__FILE__), 'abstract_session_proxy')
-
-module Sunspot
-  module SessionProxy
-    # 
-    # This is a generic abstract implementation of a session proxy that allows
-    # Sunspot to be used with a distributed (sharded) Solr deployment. Concrete
-    # subclasses should implement the #session_for method, which takes a
-    # searchable object and returns a Session that points to the appropriate
-    # Solr shard for that object. Subclasses should also implement the
-    # #all_sessions object, which returns the collection of all sharded Session
-    # objects.
-    #
-    # The class is initialized with a session that points to the Solr instance
-    # used to perform searches. Searches will have the +:shards+ param injected,
-    # containing references to the Solr instances returned by #all_sessions.
-    #
-    # For more on distributed search, see:
-    # http://wiki.apache.org/solr/DistributedSearch
-    #
-    # The following methods are not supported (although subclasses may in some
-    # cases be able to support them):
-    #
-    # * batch
-    # * config
-    # * remove_by_id
-    # * remove_by_id!
-    # * remove_all with an argument
-    # * remove_all! with an argument
-    #
-    class ShardingSessionProxy < AbstractSessionProxy
-      not_supported :batch, :config, :remove_by_id, :remove_by_id!
-
-      # 
-      # +search_session+ is the session that should be used for searching.
-      #
-      def initialize(search_session = Sunspot.session.new)
-        @search_session = search_session
-      end
-
-      # 
-      # Return the appropriate shard session for the object.
-      #
-      # <strong>Concrete subclasses must implement this method.</strong>
-      #
-      def session_for(object)
-        raise NotImplementedError
-      end
-
-      # 
-      # Return all shard sessions.
-      #
-      # <strong>Concrete subclasses must implement this method.</strong>
-      #
-      def all_sessions
-        raise NotImplementedError
-      end
-
-      # 
-      # See Sunspot.index
-      #
-      def index(*objects)
-        using_sharded_session(objects) { |session, group| session.index(group) }
-      end
-
-      # 
-      # See Sunspot.index!
-      #
-      def index!(*objects)
-        using_sharded_session(objects) { |session, group| session.index!(group) }
-      end
-
-      # 
-      # See Sunspot.remove
-      #
-      def remove(*objects)
-        using_sharded_session(objects) { |session, group| session.remove(group) }
-      end
-
-      # 
-      # See Sunspot.remove!
-      #
-      def remove!(*objects)
-        using_sharded_session(objects) { |session, group| session.remove!(group) }
-      end
-
-      # 
-      # If no argument is passed, behaves like Sunspot.remove_all
-      #
-      # If an argument is passed, will raise NotSupportedError, as the proxy
-      # does not know which session(s) to which to delegate this operation.
-      #
-      def remove_all(clazz = nil)
-        if clazz
-          raise NotSupportedError, "Sharding session proxy does not support remove_all with an argument."
-        else
-          all_sessions.each { |session| session.remove_all }
-        end
-      end
-
-      # 
-      # If no argument is passed, behaves like Sunspot.remove_all!
-      #
-      # If an argument is passed, will raise NotSupportedError, as the proxy
-      # does not know which session(s) to which to delegate this operation.
-      #
-      def remove_all!(clazz = nil)
-        if clazz
-          raise NotSupportedError, "Sharding session proxy does not support remove_all! with an argument."
-        else
-          all_sessions.each { |session| session.remove_all! }
-        end
-      end
-
-      # 
-      # Commit all shards. See Sunspot.commit
-      #
-      def commit
-        all_sessions.each { |session| session.commit }
-      end
-
-      # 
-      # Optimize all shards. See Sunspot.optimize
-      #
-      def optimize
-        all_sessions.each { |session| session.optimize }
-      end
-
-      # 
-      # Commit all dirty sessions. Only dirty sessions will be committed.
-      #
-      # See Sunspot.commit_if_dirty
-      #
-      def commit_if_dirty
-        all_sessions.each { |session| session.commit_if_dirty }
-      end
-
-      # 
-      # Commit all delete-dirty sessions. Only delete-dirty sessions will be
-      # committed.
-      # 
-      # See Sunspot.commit_if_delete_dirty
-      #
-      def commit_if_delete_dirty
-        all_sessions.each { |session| session.commit_if_delete_dirty }
-      end
-
-      # 
-      # Instantiate a new Search object, but don't execute it. The search will
-      # have an extra :shards param injected into the query, which will tell the
-      # Solr instance referenced by the search session to search across all
-      # shards.
-      #
-      # See Sunspot.new_search
-      #
-      def new_search(*types)
-        shard_urls = all_sessions.map { |session| session.config.solr.url }
-        search = @search_session.new_search(*types)
-        search.build do
-          adjust_solr_params { |params| params[:shards] = shard_urls.join(',') }
-          # I feel a little dirty doing this.
-        end
-        search
-      end
-
-      # 
-      # Build and execute a new Search. The search will have an extra :shards
-      # param injected into the query, which will tell the Solr instance
-      # referenced by the search session to search across all shards.
-      #
-      # See Sunspot.search
-      #
-      def search(*types, &block)
-        new_search(*types).execute
-      end
-
-      def more_like_this(object, &block)
-        #FIXME should use shards
-        new_more_like_this(object, &block).execute
-      end
-
-      def new_more_like_this(object, &block)
-        @search_session.new_more_like_this(object, &block)
-      end
-
-      # 
-      # True if any shard session is dirty. Note that directly using the
-      # #commit_if_dirty method is more efficient if that's what you're
-      # trying to do, since in that case only the dirty sessions are committed.
-      #
-      # See Sunspot.dirty?
-      #
-      def dirty?
-        all_sessions.any? { |session| session.dirty? }
-      end
-
-      # 
-      # True if any shard session is delete-dirty. Note that directly using the
-      # #commit_if_delete_dirty method is more efficient if that's what you're
-      # trying to do, since in that case only the delete-dirty sessions are
-      # committed.
-      #
-      def delete_dirty?
-        all_sessions.any? { |session| session.delete_dirty? }
-      end
-
-      private
-
-      # 
-      # Group the objects by which shard session they correspond to, and yield
-      # each session and is corresponding group of objects.
-      #
-      def using_sharded_session(objects)
-        grouped_objects = Hash.new { |h, k| h[k] = [] }
-        objects.flatten.each { |object| grouped_objects[session_for(object)] << object }
-        grouped_objects.each_pair do |session, group|
-          yield(session, group)
-        end
-      end
-    end
-  end
-end