solrb 0.2.3 → 0.2.8

data/lib/solr/indexing/request.rb

@@ -18,7 +18,13 @@ module Solr
       private
 
       def default_runner_options
-        { node_selection_strategy: Solr::Request::LeaderNodeSelectionStrategy }
+        if Solr.cloud_enabled?
+          { node_selection_strategy: Solr::Request::Cloud::LeaderNodeSelectionStrategy }
+        elsif Solr.master_slave_enabled?
+          { node_selection_strategy: Solr::Request::MasterSlave::MasterNodeSelectionStrategy }
+        else
+          {}
+        end
       end
 
       def build_http_request(commit)

data/lib/solr/master_slave/configuration.rb

@@ -0,0 +1,38 @@
+require 'solr/master_slave/nodes_gray_list/disabled'
+require 'solr/master_slave/nodes_gray_list/in_memory'
+
+module Solr
+  module MasterSlave
+    class Configuration
+      attr_accessor :master_url, :slave_url, :disable_read_from_master
+
+      attr_reader :master_slave_enabled
+      attr_writer :nodes_gray_list
+
+      def enable_master_slave!(_)
+        @master_slave_enabled = true
+      end
+
+      def master_slave_enabled?
+        @master_slave_enabled
+      end
+
+      def active_nodes_for(collection:)
+        urls = []
+        urls.push(master_url) unless disable_read_from_master
+        urls.push(*slave_url) if slave_url
+        nodes_gray_list.select_active(urls, collection_name: collection)
+      end
+
+      def nodes_gray_list
+        @nodes_gray_list || gray_list_disabled_instance
+      end
+
+      private
+
+      def gray_list_disabled_instance
+        @gray_list_disabled_instance ||= Solr::MasterSlave::NodesGrayList::Disabled.new
+      end
+    end
+  end
+end

data/lib/solr/master_slave/helper_methods.rb

@@ -0,0 +1,25 @@
+require 'solr/master_slave/configuration'
+
+module Solr
+  module MasterSlave
+    module HelperMethods
+      def master_slave_active_nodes_for(collection:)
+        master_slave_configuration.active_nodes_for(collection: collection)
+      end
+
+      def master_slave_enabled?
+        master_slave_configuration.master_slave_enabled?
+      end
+
+      def enable_master_slave!
+        master_slave_configuration.enable_master_slave!(configuration.cores.keys)
+      end
+
+      private
+
+      def master_slave_configuration
+        configuration.master_slave_configuration
+      end
+    end
+  end
+end

data/lib/solr/master_slave/nodes_gray_list/disabled.rb

@@ -0,0 +1,21 @@
+module Solr
+  module MasterSlave
+    module NodesGrayList
+      class Disabled
+        def add(_)
+        end
+
+        def remove(_)
+        end
+
+        def added?(_)
+          true
+        end
+
+        def select_active(urls, collection_name:)
+          urls
+        end
+      end
+    end
+  end
+end

data/lib/solr/master_slave/nodes_gray_list/in_memory.rb

@@ -0,0 +1,47 @@
+module Solr
+  module MasterSlave
+    module NodesGrayList
+      class InMemory
+        attr_reader :gray_list, :removal_period
+
+        DEFAULT_REMOVAL_PERIOD = 5 * 60 # 5 minutes in seconds
+        
+        def initialize(removal_period: DEFAULT_REMOVAL_PERIOD)
+          @gray_list = {}
+          @removal_period = removal_period
+        end
+        
+        def add(url)
+          return if gray_list.has_key?(url)
+          ::Solr.configuration.logger.info("#{url} added to a gray list")
+          gray_list[url] = Time.now.utc
+        end
+
+        def remove(url)
+          gray_list.delete(url)
+        end
+
+        def added?(url)
+          added_at = gray_list[url]
+          return false unless added_at
+
+          if added_at + removal_period > Time.now.utc
+            true
+          else
+            remove(url)
+            false
+          end
+        end
+
+        def select_active(urls, collection_name:)
+          urls = Array(urls)
+          active_urls = urls.reject do |url|
+            collection_url = File.join(url, collection_name.to_s)
+            added?(collection_url)
+          end
+          active_urls.any? ? active_urls : urls
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/handler.rb

@@ -5,21 +5,22 @@ require 'solr/query/http_request_builder'
 module Solr
   module Query
     class Handler
-      attr_reader :query, :page, :page_size
+      attr_reader :query, :rows, :start, :runner_options
 
       def self.call(opts)
-        new(opts).call
+        new(**opts).call
       end
 
-      def initialize(query:, page:, page_size:)
+      def initialize(query:, rows:, start:, runner_options: {})
         @query = query
-        @page = page
-        @page_size = page_size
+        @rows = rows
+        @start = start
+        @runner_options = runner_options || {}
       end
 
       def call
-        http_request = Solr::Query::HttpRequestBuilder.call(query: query, page: page, page_size: page_size)
-        solr_response = Solr::Request::Runner.call(request: http_request)
+        http_request = Solr::Query::HttpRequestBuilder.call(query: query, start: start, rows: rows)
+        solr_response = Solr::Request::Runner.call(request: http_request, **runner_options)
         Solr::Query::Response::Parser.new(request: query, solr_response: solr_response.body).to_response
       end
     end

data/lib/solr/query/http_request_builder.rb

@@ -5,16 +5,16 @@ module Solr
     class HttpRequestBuilder
       PATH = '/select'.freeze
 
-      attr_reader :query, :page, :page_size
+      attr_reader :query, :start, :rows
 
       def self.call(opts)
-        new(opts).call
+        new(**opts).call
       end
 
-      def initialize(query:, page:, page_size:)
+      def initialize(query:, start:, rows:)
         @query = query
-        @page = page
-        @page_size = page_size
+        @rows = rows
+        @start = start
       end
 
       def call
@@ -27,13 +27,7 @@ module Solr
 
       # 🏋️
       def build_body
-        @request_params ||= { params: solr_params.merge(wt: :json, rows: page_size.to_i, start: start) }
-      end
-
-      def start
-        start_page = page.to_i - 1
-        start_page = start_page < 1 ? 0 : start_page
-        start_page * page_size
+        @request_params ||= { params: solr_params.merge(wt: :json, rows: rows, start: start) }
       end
 
       def solr_params

data/lib/solr/query/request.rb

@@ -30,8 +30,11 @@ module Solr
         @filters = filters
       end
 
-      def run(page: 1, page_size: 10)
-        Solr::Query::Handler.call(query: self, page: page, page_size: page_size)
+      def run(page: nil, start: nil, rows: nil, page_size: nil, runner_options: {})
+        rows ||= page_size
+        return run_paged(page: page, page_size: rows, runner_options: runner_options) if page && rows
+        return run_start(start: start, rows: rows, runner_options: runner_options) if start && rows
+        raise ArgumentError, 'You must specify either page/rows or start/rows arguments'
       end
 
       def grouping
@@ -45,6 +48,20 @@ module Solr
       def to_h
         Solr::Query::Request::EdismaxAdapter.new(self).to_h
       end
+
+      private
+
+      def run_paged(page: 1, page_size: 10, runner_options:)
+        start_page = page.to_i - 1
+        start_page = start_page < 1 ? 0 : start_page
+        start = start_page * page_size
+
+        Solr::Query::Handler.call(query: self, start: start, rows: page_size, runner_options: runner_options)
+      end
+
+      def run_start(rows: 10, start: 0, runner_options:)
+        Solr::Query::Handler.call(query: self, start: start, rows: rows, runner_options: runner_options)
+      end
     end
   end
 end

data/lib/solr/query/request/boosting/dictionary_boost_function.rb

@@ -5,12 +5,13 @@ module Solr
         class DictionaryBoostFunction
           include Solr::Support::SchemaHelper
           using Solr::Support::StringExtensions
-          attr_reader :field, :dictionary
+          attr_reader :field, :dictionary, :default_boost
 
-          def initialize(field:, dictionary:)
+          def initialize(field:, dictionary:, default_boost: 1)
             raise 'dictionary must be a non-empty Hash' if Hash(dictionary).empty?
             @field = field
             @dictionary = dictionary
+            @default_boost = default_boost
           end
 
           # example: given a hash (dictionary)
@@ -21,7 +22,7 @@ module Solr
           # note that I added spaces for readability, real Solr query functions must always be w/out spaces
           def to_solr_s
             sf = solarize_field(field)
-            dictionary.to_a.reverse.reduce(1) do |acc, (field_value, boost)|
+            dictionary.to_a.reverse.reduce(default_boost) do |acc, (field_value, boost)|
               if field_value.is_a?(String) || field_value.is_a?(Symbol)
                 "if(termfreq(#{sf},\"#{field_value.to_s.solr_escape}\"),#{boost},#{acc})"
               else

data/lib/solr/query/request/facet.rb

@@ -17,7 +17,8 @@ module Solr
                     :subfacets,
                     :gap,
                     :lower_bound,
-                    :upper_bound
+                    :upper_bound,
+                    :domain
 
         def initialize(field:, type:, name: nil, value: nil, filters: [], subfacets: [], options: {})
           if options[:limit].nil? && type == TERMS_TYPE
@@ -38,6 +39,7 @@ module Solr
           @gap         = options[:gap]
           @lower_bound = options[:lower_bound]
           @upper_bound = options[:upper_bound]
+          @domain      = options[:domain]
         end
 
         def to_solr_h
@@ -58,7 +60,8 @@ module Solr
               facet: subfacets.map(&:to_solr_h).reduce(&:merge),
               gap: gap,
               start: lower_bound,
-              end: upper_bound
+              end: upper_bound,
+              domain: domain
             }.compact
           }
         end

data/lib/solr/request/cloud/first_shard_leader_node_selection_strategy.rb

@@ -0,0 +1,27 @@
+module Solr
+  module Request
+    module Cloud
+      class FirstShardLeaderNodeSelectionStrategy < NodeSelectionStrategy
+        def call
+          leader = first_shard_leader_replica_node_for(collection: collection_name)
+          replicas = solr_cloud_active_nodes_urls.shuffle
+          urls = ([leader] + replicas).flatten.uniq
+          map_urls_to_collections(urls)
+        end
+
+        private
+
+        def first_shard_leader_replica_node_for(collection:)
+          shards = Solr.shards_for(collection: collection)
+          return unless shards
+          first_shard_name = shards.sort.first
+          Solr.leader_replica_node_for(collection: collection, shard: first_shard_name)
+        end
+
+        def solr_cloud_active_nodes_urls
+          Solr.active_nodes_for(collection: collection_name)
+        end
+      end
+    end
+  end
+end

data/lib/solr/request/cloud/leader_node_selection_strategy.rb

@@ -0,0 +1,21 @@
+module Solr
+  module Request
+    module Cloud
+      class LeaderNodeSelectionStrategy < NodeSelectionStrategy
+        def call
+          urls = [leader_replica_node_for(collection: collection_name)]
+          map_urls_to_collections(urls)
+        end
+
+        private
+
+        def leader_replica_node_for(collection:)
+          shards = Solr.shards_for(collection: collection)
+          return unless shards
+          first_shard_name = shards.sort.first
+          Solr.leader_replica_node_for(collection: collection, shard: first_shard_name)
+        end
+      end
+    end
+  end
+end

data/lib/solr/request/default_node_selection_strategy.rb

@@ -2,7 +2,8 @@ module Solr
   module Request
     class DefaultNodeSelectionStrategy < NodeSelectionStrategy
       def call
-        Solr.active_nodes_for(collection: collection_name).shuffle
+        urls = Solr.active_nodes_for(collection: collection_name)
+        map_urls_to_collections(urls).shuffle
       end
     end
   end

data/lib/solr/request/master_slave/master_node_selection_strategy.rb

@@ -0,0 +1,12 @@
+module Solr
+  module Request
+    module MasterSlave
+      class MasterNodeSelectionStrategy < NodeSelectionStrategy
+        def call
+          urls = [Solr.configuration.master_url]
+          map_urls_to_collections(urls)
+        end
+      end
+    end
+  end
+end

data/lib/solr/request/node_selection_strategy.rb

@@ -14,6 +14,12 @@ module Solr
       def call
         raise "Not implemented"
       end
+
+      private
+
+      def map_urls_to_collections(urls)
+        urls&.map { |u| File.join(u, collection_name.to_s) }
+      end
     end
   end
 end

data/lib/solr/request/runner.rb

@@ -1,7 +1,8 @@
 require 'solr/request/node_selection_strategy'
 require 'solr/request/default_node_selection_strategy'
-require 'solr/request/first_shard_leader_node_selection_strategy'
-require 'solr/request/leader_node_selection_strategy'
+require 'solr/request/cloud/first_shard_leader_node_selection_strategy'
+require 'solr/request/cloud/leader_node_selection_strategy'
+require 'solr/request/master_slave/master_node_selection_strategy'
 require 'solr/errors/solr_query_error'
 require 'solr/errors/solr_connection_failed_error'
 require 'solr/errors/no_active_solr_nodes_error'
@@ -15,7 +16,7 @@ module Solr
       attr_reader :request, :response_parser, :node_selection_strategy
 
       def self.call(opts)
-        new(opts).call
+        new(**opts).call
       end
 
       def initialize(request:,
@@ -28,6 +29,7 @@ module Solr
       end
 
       def call
+        solr_url_errors = {}
         solr_urls.each do |node_url|
           request_url = build_request_url(url: node_url,
                                           path: request.path,
@@ -37,19 +39,29 @@ module Solr
             solr_response = Solr::Response::Parser.call(raw_response)
             raise Solr::Errors::SolrQueryError, solr_response.error_message unless solr_response.ok?
             return solr_response
-          rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Errno::EADDRNOTAVAIL => e
+          rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Errno::EADDRNOTAVAIL, Timeout::Error => e
+            if Solr.master_slave_enabled?
+              Solr.configuration.nodes_gray_list.add(node_url)
+            end
+            solr_url_errors[node_url] = "#{e.class.name} - #{e.message}"
             # Try next node
           end
         end
 
-        raise Solr::Errors::SolrConnectionFailedError.new(solr_urls)
+        raise Solr::Errors::SolrConnectionFailedError.new(solr_url_errors)
       end
 
       private
 
       def solr_urls
         @solr_urls ||= begin
-          urls = Solr.cloud_enabled? ? solr_cloud_collection_urls : [Solr.current_core_config.url]
+          urls = if Solr.node_url_override
+            [File.join(Solr.node_url_override, collection_name.to_s)]
+          elsif Solr.cloud_enabled? || Solr.master_slave_enabled?
+            node_selection_strategy.call(collection_name)
+          else
+            [Solr.current_core_config.url]
+          end
           unless urls && urls.any?
             raise Solr::Errors::NoActiveSolrNodesError
           end
@@ -57,11 +69,6 @@ module Solr
         end
       end
 
-      def solr_cloud_collection_urls
-        urls = node_selection_strategy.call(collection_name)
-        urls&.map { |u| File.join(u, collection_name.to_s) }
-      end
-
       def collection_name
         Solr.current_core_config.name
       end