solrb 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f60f6a0571ce8fd909c4fd286f93ff5f57b6874597bc5980207eb97f6d43438f
-  data.tar.gz: df632f68830e1ffb178fd5dfcc757e8f2a11a397fdc3f49c8da112d0e076543b
+  metadata.gz: 9ec22b8f3fb8d4af1362389b30173de437f3a66e0a56fd11189a66aa28c0a4f2
+  data.tar.gz: 36ae13f391bc00291bd4661c1ac910b6cdc2242f0c090a64d11c2385bca39274
 SHA512:
-  metadata.gz: a363f5c19f5cbb71cdbd24bb1387f93c7c9b7003fb1dac1f1dd0d538052fe2f7f5de333ae4f8208d2533acbc53d92ee38e2d4ad975022ae6456f04c33b9cf01d
-  data.tar.gz: b3fd3713b0f78420ee9491bbc2ea930b3aed58885af7623cf7475efe703d477f200e903282473088bb78014fa98d6ad897c7a028a7b422016fd264bd582c3694
+  metadata.gz: ef11a6e93954a9b5245861b4753f722aa6f936f91fe2523ac4c31b685cf300cb37ae07247b24e70515914053d2e96330501bcb213c07aeef15cc6168c5540c71
+  data.tar.gz: 743961e7ae4540f4e67362554470bc3485ddab0ddfc557d4b0d27fd99b51c91b64c333e2a24a9a7839b9d87d7b514142e4302a701ba73f4a51be20a213f12c8c

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+.ruby-version

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    solrb (0.1.3)
+    solrb (0.1.9)
       addressable
       faraday
 
@@ -15,7 +15,7 @@ GEM
     coderay (1.1.2)
     diff-lcs (1.3)
     docile (1.3.1)
-    faraday (0.15.2)
+    faraday (0.15.3)
       multipart-post (>= 1.2, < 3)
     jaro_winkler (1.5.1)
     json (2.1.0)
@@ -80,4 +80,4 @@ DEPENDENCIES
   solrb!
 
 BUNDLED WITH
-   1.16.4
+   1.16.6

data/README.md

@@ -7,15 +7,15 @@ Solrb
 
 Object-Oriented approach to Solr in Ruby.
 
-Installation: `gem install solrb`
-
 ## Table of contents
 
-
+* [Installation](#installation)
 * [Configuration](#configuration)
   * [Setting Solr URL via environment variable](#setting-solr-url-via-environment-variable)
   * [Single core configuration](#single-core-configuration)
   * [Multiple core configuration](#multiple-core-configuration)
+  * [Solr Cloud](#solr-cloud)
+  * [Basic Authentication](#basic-authentication)
 * [Indexing](#indexing)
 * [Querying](#querying)
   * [Simple Query](#simple-query)
@@ -34,6 +34,20 @@ Installation: `gem install solrb`
 * [Running specs](#running-specs)
 
 
+# Installation
+
+Add `solrb` to your Gemfile:
+
+```ruby
+gem solrb
+```
+
+If you are going to use solrb with solr cloud:
+
+```ruby
+gem zk # required for solrb solr-cloud integration
+gem solrb
+```
 
 # Configuration
 
@@ -122,6 +136,45 @@ end
 ...
 ```
 
+## Solr Cloud
+
+To enable solr cloud mode you must define a zookeeper url on solr config block.
+In solr cloud mode you don't need to provide a solr url (`config.url` or `ENV['SOLR_URL']`).
+Solrb will watch the zookeeper state to receive up-to-date information about active solr nodes including the solr urls.
+
+
+You can also specify the ACL credentials for Zookeeper. [More Information](https://lucene.apache.org/solr/guide/7_6/zookeeper-access-control.html#ZooKeeperAccessControl-AboutZooKeeperACLs)
+
+
+```ruby
+Solr.configure do |config|
+  config.zookeeper_urls = ['localhost:2181', 'localhost:2182', 'localhost:2183']
+  config.zookeeper_auth_user = 'zk_acl_user'
+  config.zookeeper_auth_password = 'zk_acl_password'
+end
+```
+
+If you are using puma web server in clustered mode you must call `enable_solr_cloud!` on `on_worker_boot`
+callback to make each puma worker connect with zookeeper.
+
+
+```ruby
+on_worker_boot do
+  Solr.enable_solr_cloud!
+end
+```
+
+## Basic Authentication
+
+Basic authentication is supported by solrb. You can enable it by providing `auth_user` and `auth_password`
+on the config block.
+
+```ruby
+Solr.configure do |config|
+  config.auth_user = 'user'
+  config.auth_password = 'password'
+end
+```
 
 # Indexing
 

data/lib/solr/cloud/collections_state_manager.rb

@@ -0,0 +1,48 @@
+module Solr
+  module Cloud
+    class CollectionsStateManager
+      attr_reader :zookeeper, :collections, :collections_state
+
+      def initialize(zookeeper:, collections:)
+        @zookeeper = zookeeper
+        @collections = collections
+        @collections_state = {}
+        watch_solr_collections_state
+      end
+
+      def shards_for(collection:)
+        collections_state.dig(collection.to_s, 'shards').keys
+      end
+
+      def active_nodes_for(collection:)
+        shards = collections_state.dig(collection.to_s, 'shards')
+        return unless shards
+        shards.flat_map do |_, shard|
+          shard['replicas'].select do |_, replica|
+            replica['state'] == 'active'
+          end.flat_map do |_, replica|
+            replica['base_url']
+          end
+        end.uniq
+      end
+
+      def leader_replica_node_for(collection:, shard:)
+        shards = collections_state.dig(collection.to_s, 'shards')
+        return unless shards
+        shard_replicas = shards[shard.to_s]
+        leader_replica = shard_replicas['replicas'].detect do |_, replica|
+          replica['state'] == 'active' && replica['leader'] == 'true'
+        end
+        leader_replica.last['base_url'] if leader_replica
+      end
+
+      def watch_solr_collections_state
+        collections.each do |collection_name|
+          zookeeper.watch_collection_state(collection_name) do |state|
+            @collections_state[collection_name.to_s] = state
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/cloud/configuration.rb

@@ -0,0 +1,27 @@
+require 'solr/cloud/zookeeper_connection'
+require 'solr/cloud/collections_state_manager'
+
+module Solr
+  module Cloud
+    class Configuration
+      attr_accessor :zookeeper_url, :zookeeper_auth_user, :zookeeper_auth_password
+
+      attr_reader :collections_state_manager
+
+      def enable_solr_cloud!(collections)
+        @collections_state_manager = Solr::Cloud::CollectionsStateManager.new(zookeeper: build_zookeeper_connection,
+                                                                              collections: collections)
+      end
+
+      def cloud_enabled?
+        !@collections_state_manager.nil?
+      end
+
+      def build_zookeeper_connection
+        Solr::Cloud::ZookeeperConnection.new(zookeeper_url: zookeeper_url.is_a?(Array) ? zookeeper_url.join(',') : zookeeper_url,
+                                             zookeeper_auth_user: zookeeper_auth_user,
+                                             zookeeper_auth_password: zookeeper_auth_password)
+      end
+    end
+  end
+end

data/lib/solr/cloud/helper_methods.rb

@@ -0,0 +1,37 @@
+require 'solr/cloud/configuration'
+
+module Solr
+  module Cloud
+    module HelperMethods
+      def active_nodes_for(collection:)
+        collections_state_manager.active_nodes_for(collection: collection)
+      end
+
+      def leader_replica_node_for(collection:, shard:)
+        collections_state_manager.leader_replica_node_for(collection: collection, shard: shard)
+      end
+
+      def shards_for(collection:)
+        collections_state_manager.shards_for(collection: collection)
+      end
+
+      def cloud_enabled?
+        cloud_configuration.cloud_enabled?
+      end
+
+      def enable_solr_cloud!
+        cloud_configuration.enable_solr_cloud!(configuration.cores.keys)
+      end
+
+      private
+
+      def collections_state_manager
+        cloud_configuration.collections_state_manager
+      end
+
+      def cloud_configuration
+        configuration.cloud_configuration
+      end
+    end
+  end
+end

data/lib/solr/cloud/zookeeper_connection.rb

@@ -0,0 +1,64 @@
+require 'solr/errors/zookeeper_required'
+
+module Solr
+  module Cloud
+    class ZookeeperConnection
+      attr_reader :zookeeper_url, :zookeeper_auth_user, :zookeeper_auth_password
+
+      def initialize(zookeeper_url:, zookeeper_auth_user: nil, zookeeper_auth_password: nil)
+        @zookeeper_url = zookeeper_url
+        @zookeeper_auth_user = zookeeper_auth_user
+        @zookeeper_auth_password = zookeeper_auth_password
+      end
+
+      def watch_collection_state(collection_name, &block)
+        collection_state_znode = collection_state_znode_path(collection_name)
+        zookeeper_connection.register(collection_state_znode) do |event|
+          state = get_collection_state(collection_name, watch: true)
+          block.call(state)
+        end
+        state = get_collection_state(collection_name, watch: true)
+        block.call(state)
+      end
+
+      def get_collection_state(collection_name, watch: true)
+        collection_state_znode = collection_state_znode_path(collection_name)
+        znode_data = zookeeper_connection.get(collection_state_znode, watch: watch)
+        return unless znode_data
+        JSON.parse(znode_data.first)[collection_name.to_s]
+      end
+
+      def collection_state_znode_path(collection_name)
+        "/collections/#{collection_name}/state.json"
+      end
+
+      private
+
+      def zookeeper_connection
+        @zookeeper_connection ||= build_zookeeper_connection
+      end
+
+      def build_zookeeper_connection
+        raise 'You must provide a ZooKeeper URL to enable solr cloud mode' unless zookeeper_url
+        raise Solr::Errors::ZookeeperRequired unless require_zk
+
+        zk = ZK.new(zookeeper_url)
+        zk.add_auth(scheme: 'digest', cert: zookeeper_auth) if zookeeper_auth
+        zk
+      end
+
+      def zookeeper_auth
+        if zookeeper_auth_user && zookeeper_auth_password
+          "#{zookeeper_auth_user}:#{zookeeper_auth_password}"
+        end
+      end
+
+      def require_zk
+        require 'zk'
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end

data/lib/solr/commands.rb

@@ -0,0 +1,24 @@
+require 'solr/delete/request'
+require 'solr/commit/request'
+require 'solr/query/request'
+require 'solr/data_import/request'
+
+module Solr
+  module Commands
+    def commit
+      Solr::Commit::Request.new.run
+    end
+
+    def delete_by_id(id, commit: false)
+      Solr::Delete::Request.new(id: id).run(commit: commit)
+    end
+
+    def delete_by_query(query, commit: false)
+      Solr::Delete::Request.new(query: query).run(commit: commit)
+    end
+
+    def data_import(params)
+      Solr::DataImport::Request.new(params).run
+    end
+  end
+end

data/lib/solr/commit/request.rb

@@ -1,14 +1,11 @@
 module Solr
   module Commit
     class Request
-      include Solr::Support::ConnectionHelper
       PATH = '/update'.freeze
 
       def run
-        # the way to do commit message in SOLR is to send an empty 
-        # request with ?commit=true in the URL.
-        raw_response = connection(PATH, commit: true).post
-        Solr::Response.from_raw_response(raw_response)
+        http_request = Solr::Request::HttpRequest.new(path: PATH, url_params: { commit: true }, method: :post)
+        Solr::Request::Runner.call(request: http_request)
       end
     end
   end

data/lib/solr/configuration.rb

@@ -4,13 +4,19 @@ require 'solr/core_configuration/core_config'
 require 'solr/core_configuration/core_config_builder'
 require 'solr/errors/solr_url_not_defined_error'
 require 'solr/errors/ambiguous_core_error'
+require 'solr/errors/could_not_infer_implicit_core_name'
 
 module Solr
   class Configuration
+    extend Forwardable
+
+    delegate [:zookeeper_url, :zookeeper_url=, :zookeeper_auth_user=, :zookeeper_auth_password=] => :@cloud_configuration
+
     SOLRB_USER_AGENT_HEADER = { user_agent: "Solrb v#{Solr::VERSION}" }.freeze
 
-    attr_accessor :cores, :test_connection
-    attr_reader :url, :faraday_options
+    attr_accessor :cores, :test_connection, :auth_user, :auth_password
+
+    attr_reader :url, :faraday_options, :cloud_configuration
 
     def initialize
       @faraday_options = {
@@ -18,6 +24,7 @@ module Solr
         headers: SOLRB_USER_AGENT_HEADER
       }
       @cores = {}
+      @cloud_configuration = Solr::Cloud::Configuration.new
     end
 
     def faraday_options=(options)
@@ -41,7 +48,7 @@ module Solr
     def default_core_config
       defined_default_core_config = cores.values.detect(&:default?)
       return defined_default_core_config if defined_default_core_config
-      raise Errors::AmbiguousCoreError if cores.count > 1
+      raise Solr::Errors::AmbiguousCoreError if cores.count > 1
       cores.values.first || build_env_url_core_config
     end
 
@@ -60,7 +67,19 @@ module Solr
       end
     end
 
+    def core_name_from_solr_url_env
+      full_solr_core_uri = URI.parse(ENV['SOLR_URL'])
+      core_name = full_solr_core_uri.path.gsub('/solr', '').delete('/')
+
+      if !core_name || core_name == ''
+        raise Solr::Errors::CouldNotInferImplicitCoreName
+      end
+
+      core_name
+    end
+
     def build_env_url_core_config(name: nil)
+      name ||= core_name_from_solr_url_env
       Solr::CoreConfiguration::EnvUrlCoreConfig.new(name: name)
     end
 
@@ -70,5 +89,11 @@ module Solr
         raise ArgumentError, 'Only one default core can be specified'
       end
     end
+
+    def validate!
+      if !(url || @cloud_configuration.zookeeper_url || ENV['SOLR_URL'])
+        raise Solr::Errors::SolrUrlNotDefinedError
+      end
+    end
   end
 end

data/lib/solr/connection.rb

@@ -5,23 +5,20 @@ module Solr
 
     def initialize(url, faraday_options: Solr.configuration.faraday_options)
       # Allow mock the connection for testing
-      @raw_connection = Solr.configuration.test_connection || Faraday.new(url, faraday_options)
+      @raw_connection = Solr.configuration.test_connection || build_faraday_connection(url, faraday_options)
       freeze
     end
 
-    def get 
-      Solr.instrument(name: INSTRUMENT_KEY) { @raw_connection.get }
+    def self.call(url:, method:, body:)
+      raise "HTTP method not supported: #{method}" unless [:get, :post].include?(method.to_sym)
+      new(url).public_send(method, body)
     end
 
-    def post(data = {})
-      Solr.instrument(name: INSTRUMENT_KEY) do 
-        @raw_connection.post do |req|
-          req.body = data
-        end
-      end
+    def get(_)
+      Solr.instrument(name: INSTRUMENT_KEY) { @raw_connection.get }
     end
 
-    def post_as_json(data)
+    def post(data)
       Solr.instrument(name: INSTRUMENT_KEY, data: data) do
         @raw_connection.post do |req|
           req.headers['Content-Type'] = 'application/json'.freeze
@@ -29,5 +26,15 @@ module Solr
         end
       end
     end
+
+    private
+
+    def build_faraday_connection(url, faraday_options)
+      connection = Faraday.new(url, faraday_options)
+      if Solr.configuration.auth_user && Solr.configuration.auth_password
+        connection.basic_auth(Solr.configuration.auth_user, Solr.configuration.auth_password)
+      end
+      connection
+    end
   end
 end

data/lib/solr/core_configuration/core_config_builder.rb

@@ -3,7 +3,7 @@ module Solr
     class CoreConfigBuilder
       attr_reader :name, :dynamic_fields, :fields_params, :default
 
-      def initialize(name: nil, default:)
+      def initialize(name:, default:)
         @name = name
         @default = default
         @dynamic_fields = {}

data/lib/solr/data_import/request.rb

@@ -0,0 +1,27 @@
+require 'solr/request/first_shard_leader_node_selection_strategy'
+
+module Solr
+  module DataImport
+    class Request
+      PATH = '/dataimport'.freeze
+
+      attr_reader :params
+
+      def initialize(params)
+        @params = params
+      end
+
+      # We want to make sure we send every dataimport request to the same node because this same class
+      # could be used to start a dataimport and to get dataimport progress data afterwards.
+      # To make it consistent we will send dataimport requests only to the first shard leader replica
+      def run
+        http_request = Solr::Request::HttpRequest.new(path: PATH, url_params: params, method: :get)
+        Solr::Request::Runner.call(request: http_request, node_selection_strategy: build_node_selection_strategy)
+      end
+
+      def build_node_selection_strategy
+        Solr::Request::FirstShardLeaderNodeSelectionStrategy
+      end
+    end
+  end
+end

data/lib/solr/delete/request.rb

@@ -1,7 +1,6 @@
 module Solr
   module Delete
     class Request
-      include Solr::Support::ConnectionHelper
       using Solr::Support::HashExtensions
 
       PATH = '/update'.freeze
@@ -14,13 +13,16 @@ module Solr
       end
 
       def run(commit: false)
-        # need to think how to move out commit data from the connection, it doesn't belong there
-        raw_response = connection(PATH, commit: commit).post_as_json(delete_command)
-        Solr::Response.from_raw_response(raw_response)
+        http_request = build_http_request(commit)
+        Solr::Request::Runner.call(request: http_request)
       end
 
       private
 
+      def build_http_request(commit)
+        Solr::Request::HttpRequest.new(path: PATH, body: delete_command, url_params: { commit: commit }, method: :post)
+      end
+
       def validate_delete_options!(options)
         options = options.deep_symbolize_keys
         id, query = options.values_at(:id, :query)

data/lib/solr/errors/ambiguous_core_error.rb

@@ -1,9 +1,11 @@
-module Errors
-  class AmbiguousCoreError < StandardError
-    ERROR_MESSAGE = 'Multiple cores defined: default core can\'t be found'.freeze
+module Solr
+  module Errors
+    class AmbiguousCoreError < StandardError
+      ERROR_MESSAGE = 'Multiple cores defined: default core can\'t be found'.freeze
 
-    def initialize
-      super(ERROR_MESSAGE)
+      def initialize
+        super(ERROR_MESSAGE)
+      end
     end
   end
 end

data/lib/solr/errors/could_not_infer_implicit_core_name.rb

@@ -0,0 +1,15 @@
+module Solr
+  module Errors
+    class CouldNotInferImplicitCoreName < StandardError
+      MESSAGE = '
+        TODO: Add message
+
+      '.freeze
+
+      def initialize
+        super(MESSAGE)
+      end
+    end
+  end
+end
+

data/lib/solr/errors/no_active_solr_nodes_error.rb

@@ -0,0 +1,6 @@
+module Solr
+  module Errors
+    class NoActiveSolrNodesError < StandardError
+    end
+  end
+end

data/lib/solr/errors/solr_connection_failed_error.rb

@@ -0,0 +1,13 @@
+module Solr
+  module Errors
+    class SolrConnectionFailedError < StandardError
+      def initialize(solr_urls)
+        message = <<~MESSAGE
+          Could not connection to any available solr instance:
+          #{solr_urls.join(', ')}
+        MESSAGE
+        super(message)
+      end
+    end
+  end
+end

data/lib/solr/errors/solr_query_error.rb

@@ -1,4 +1,6 @@
-module Errors
-  class SolrQueryError < StandardError
+module Solr
+  module Errors
+    class SolrQueryError < StandardError
+    end
   end
 end

data/lib/solr/errors/solr_url_not_defined_error.rb

@@ -1,16 +1,29 @@
-module Errors
-  class SolrUrlNotDefinedError < StandardError
-    SOLR_URL_NOT_DEFINED_MESSAGE = '
-      Solrb gem requires you to set the URL of your Solr instance
-      either through SOLR_URL environmental variable or explicitly inside the configure block:
+module Solr
+  module Errors
+    class SolrUrlNotDefinedError < StandardError
+      SOLR_URL_NOT_DEFINED_MESSAGE = '
+        Solrb gem requires you to set the URL of your Solr instance
+        either through SOLR_URL environmental variable or explicitly inside the configure block:
 
-      Solr.configure do |config|
-        config.url = "http://localhost:8983/solr/core"
-      end
-    '.freeze
+        Solr.configure do |config|
+          config.url = "http://localhost:8983/solr/core"
+        end
+
+        If you are using Solr cloud you can specify the zookeeper ensemble urls inside the configure block
+        and solrb will automatically get the solr urls from ZK:
+
+        Solr.configure do |config|
+          config.zookeeper_url = ["localhost:2181","localhost:2182","localhost:2183"]
+        end
+
+        For more information please check the solrb README file.
 
-    def initialize
-      super(SOLR_URL_NOT_DEFINED_MESSAGE)
+      '.freeze
+
+      def initialize
+        super(SOLR_URL_NOT_DEFINED_MESSAGE)
+      end
     end
   end
 end
+

data/lib/solr/errors/zookeeper_required.rb

@@ -0,0 +1,19 @@
+module Solr
+  module Errors
+    class ZookeeperRequired < StandardError
+      ZOOKEEPER_REQUIRED_MESSAGE = '
+
+        Solrb gem requires zookeeper for solr-cloud support.
+        Please add "zk" gem to your Gemfile and run bundle install:
+
+        gem "zk"
+
+      '.freeze
+
+      def initialize
+        super(ZOOKEEPER_REQUIRED_MESSAGE)
+      end
+    end
+  end
+end
+

data/lib/solr/indexing/request.rb

@@ -1,9 +1,8 @@
+require 'solr/request/http_request'
+
 module Solr
   module Indexing
     class Request
-      include Solr::Support::ConnectionHelper
-
-      # TODO: potentially make handlers configurable and have them handle the path
       PATH = '/update'.freeze
 
       attr_reader :documents
@@ -13,9 +12,14 @@ module Solr
       end
 
       def run(commit: false)
-        # need to think how to move out commit data from the connection, it doesn't belong there
-        raw_response = connection(PATH, commit: commit).post_as_json(documents)
-        Solr::Response.from_raw_response(raw_response)
+        http_request = build_http_request(commit)
+        Solr::Request::Runner.call(request: http_request)
+      end
+
+      private
+
+      def build_http_request(commit)
+        Solr::Request::HttpRequest.new(path: PATH, body: documents, url_params: { commit: commit }, method: :post)
       end
     end
   end

data/lib/solr/query/handler.rb

@@ -0,0 +1,27 @@
+require 'solr/query/response'
+require 'solr/request/runner'
+require 'solr/query/http_request_builder'
+
+module Solr
+  module Query
+    class Handler
+      attr_reader :query, :page, :page_size
+
+      def self.call(opts)
+        new(opts).call
+      end
+
+      def initialize(query:, page:, page_size:)
+        @query = query
+        @page = page
+        @page_size = page_size
+      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)
+        Solr::Query::Response::Parser.new(request: query, solr_response: solr_response.body).to_response
+      end
+    end
+  end
+end

data/lib/solr/query/http_request_builder.rb

@@ -0,0 +1,44 @@
+require 'solr/request/http_request'
+
+module Solr
+  module Query
+    class HttpRequestBuilder
+      PATH = '/select'.freeze
+
+      attr_reader :query, :page, :page_size
+
+      def self.call(opts)
+        new(opts).call
+      end
+
+      def initialize(query:, page:, page_size:)
+        @query = query
+        @page = page
+        @page_size = page_size
+      end
+
+      def call
+        Solr::Request::HttpRequest.new(path: PATH,
+                                       body: build_body,
+                                       method: :post)
+      end
+
+      private
+
+      # 🏋️
+      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
+      end
+
+      def solr_params
+        query.to_h
+      end
+    end
+  end
+end

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

@@ -38,21 +38,19 @@ module Solr
         private
 
         def solr_prefix
-          '-' if NOT_EQUAL_TYPE == @type
+          '-' if NOT_EQUAL_TYPE == type
         end
 
         def to_interval_solr_value(range)
           solr_min = to_primitive_solr_value(range.first)
-          solr_max = if date_infinity?(range.last) || range.last.to_f.infinite?
-                       '*'
-                     else
-                       to_primitive_solr_value(range.last)
-                     end
+          solr_max = to_primitive_solr_value(range.last)
           "[#{solr_min} TO #{solr_max}]"
         end
 
         def to_primitive_solr_value(value)
-          if date_or_time?(value)
+          if date_infinity?(value) || numeric_infinity?(value)
+            '*'
+          elsif date_or_time?(value)
             value.strftime('%Y-%m-%dT%H:%M:%SZ')
           else
             %("#{value.to_s.solr_escape}")
@@ -63,6 +61,10 @@ module Solr
           value.is_a?(DateTime::Infinity)
         end
 
+        def numeric_infinity?(value)
+          value.is_a?(Numeric) && value.infinite?
+        end
+
         def date_or_time?(value)
           return false unless value
           value.is_a?(::Date) || value.is_a?(::Time)

data/lib/solr/query/request.rb

@@ -12,9 +12,7 @@ require 'solr/query/request/sorting/function'
 require 'solr/query/request/field_with_boost'
 require 'solr/query/request/or_filter'
 require 'solr/query/request/and_filter'
-require 'solr/query/request/runner'
-require 'solr/query/response'
-require 'solr/errors/solr_query_error'
+require 'solr/query/handler'
 
 module Solr
   module Query
@@ -30,13 +28,8 @@ module Solr
         @filters = filters
       end
 
-      # Runs this Solr::Request against Solr and
-      # returns [Solr::Response]
       def run(page: 1, page_size: 10)
-        solr_params = Solr::Query::Request::EdismaxAdapter.new(self).to_h
-        solr_response = Solr::Query::Request::Runner.run(page: page, page_size: page_size, solr_params: solr_params)
-        raise Errors::SolrQueryError, solr_response.error_message unless solr_response.ok?
-        Solr::Query::Response::Parser.new(request: self, solr_response: solr_response.body).to_response
+        Solr::Query::Handler.call(query: self, page: page, page_size: page_size)
       end
 
       def grouping
@@ -46,6 +39,10 @@ module Solr
       def sorting
         @sorting ||= Solr::Query::Request::Sorting.none
       end
+
+      def to_h
+        Solr::Query::Request::EdismaxAdapter.new(self).to_h
+      end
     end
   end
 end

data/lib/solr/request/default_node_selection_strategy.rb

@@ -0,0 +1,19 @@
+module Solr
+  module Request
+    class DefaultNodeSelectionStrategy
+      attr_reader :collection_name
+
+      def self.call(collection_name)
+        new(collection_name).call
+      end
+
+      def initialize(collection_name)
+        @collection_name = collection_name
+      end
+
+      def call
+        Solr.active_nodes_for(collection: collection_name).shuffle
+      end
+    end
+  end
+end

data/lib/solr/request/first_shard_leader_node_selection_strategy.rb

@@ -0,0 +1,32 @@
+module Solr
+  module Request
+    class FirstShardLeaderNodeSelectionStrategy
+      def self.call(collection_name)
+        new(collection_name).call
+      end
+
+      def initialize(collection_name)
+        @collection_name = collection_name
+      end
+
+      def call
+        return [solr_url] unless Solr.cloud_enabled?
+
+        ([first_shard_leader_replica_node_for(collection: @collection_name)] + solr_cloud_active_nodes_urls.shuffle).flatten.uniq
+      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

data/lib/solr/request/http_request.rb

@@ -0,0 +1,14 @@
+module Solr
+  module Request
+    class HttpRequest
+      attr_reader :path, :body, :url_params, :method
+
+      def initialize(path: '/', body: {}, url_params: {}, method: :get)
+        @path = path
+        @body = body
+        @url_params = url_params
+        @method = method
+      end
+    end
+  end
+end

data/lib/solr/request/runner.rb

@@ -0,0 +1,70 @@
+require 'solr/request/default_node_selection_strategy'
+require 'solr/errors/solr_query_error'
+require 'solr/errors/solr_connection_failed_error'
+require 'solr/errors/no_active_solr_nodes_error'
+
+module Solr
+  module Request
+    # TODO: Add documentation about request running
+    class Runner
+      include Solr::Support::UrlHelper
+
+      attr_reader :request, :response_parser, :node_selection_strategy
+
+      def self.call(opts)
+        new(opts).call
+      end
+
+      def initialize(request:,
+                     node_selection_strategy: Solr::Request::DefaultNodeSelectionStrategy,
+                     solr_connection: Solr::Connection)
+        @request = request
+        @response_parser = response_parser
+        @node_selection_strategy = node_selection_strategy
+        @solr_connection = solr_connection
+      end
+
+      def call
+        solr_urls.each do |node_url|
+          request_url = build_request_url(url: node_url,
+                                          path: request.path,
+                                          url_params: request.url_params)
+          begin
+            raw_response = @solr_connection.call(url: request_url.to_s, method: request.method, body: request.body)
+            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
+            # Try next node
+          end
+        end
+
+        raise Solr::Errors::SolrConnectionFailedError.new(solr_urls)
+      end
+
+      private
+
+      def solr_urls
+        @solr_urls ||= begin
+          urls = Solr.cloud_enabled? ? solr_cloud_collection_urls : [Solr.current_core_config.url]
+          unless urls && urls.any?
+            raise Solr::Errors::NoActiveSolrNodesError
+          end
+          urls
+        end
+      end
+
+      def solr_cloud_collection_urls
+        urls = node_selection_strategy.call(collection_name)
+        return unless urls
+        urls.map do |url|
+          File.join(url, collection_name.to_s)
+        end
+      end
+
+      def collection_name
+        Solr.current_core_config.name
+      end
+    end
+  end
+end

data/lib/solr/response/parser.rb

@@ -1,11 +1,15 @@
 module Solr
   class Response
     class Parser
+      def self.call(raw_response)
+        new(raw_response).call
+      end
+
       def initialize(raw_response)
         @raw_response = raw_response
       end
 
-      def parse
+      def call
         # 404 is a special case, it didn't hit Solr (more likely than not)
         return not_found_response if @raw_response.status == 404
         parsed_body = JSON.parse(@raw_response.body).freeze

data/lib/solr/response.rb

@@ -7,10 +7,6 @@ module Solr
   class Response
     OK = 'OK'.freeze
 
-    def self.from_raw_response(response)
-      Solr::Response::Parser.new(response).parse
-    end
-
     attr_reader :header, :http_status, :solr_error, :body
 
     def initialize(header:, http_status: HttpStatus.ok, solr_error: SolrError.none, body: {})

data/lib/solr/support/url_helper.rb

@@ -1,12 +1,33 @@
 module Solr
   module Support
     module UrlHelper
-      def self.solr_url(path, url_params: {})
-        full_url = File.join(Solr.current_core_config.uri, path)
+      module_function
+
+      def solr_url(path, url_params: {})
+        full_url = File.join(core_url, path)
         full_uri = Addressable::URI.parse(full_url)
         full_uri.query_values = url_params if url_params.any?
         full_uri
       end
+
+      def build_request_url(url:,path:, url_params: {})
+        action_url = File.join(url, path).chomp('/')
+        full_uri = Addressable::URI.parse(action_url)
+        full_uri.query_values = url_params if url_params && url_params.any?
+        full_uri
+      end
+
+      def core_url
+        Solr.cloud_enabled? ? solr_cloud_url : current_core.uri
+      end
+
+      def solr_cloud_url
+        File.join(Solr.active_nodes_for(collection: current_core.name.to_s).first, current_core.name.to_s)
+      end
+
+      def current_core
+        Solr.current_core_config
+      end
     end
   end
 end

data/lib/solr/testing.rb

@@ -6,14 +6,14 @@ module Solr
   end
 end
 
-module Solr::Query::Request::RunnerExtension
-  def run
+module Solr::Request::RunnerExtension
+  def call
     response = super
-    Solr::Testing.last_solr_request_params = request_params[:params]
+    Solr::Testing.last_solr_request_params = request.body ? request.body[:params] : nil
     response
   end
 end
 
-class Solr::Query::Request::Runner
-  prepend Solr::Query::Request::RunnerExtension
+class Solr::Request::Runner
+  prepend Solr::Request::RunnerExtension
 end

data/lib/solr/version.rb

@@ -1,3 +1,3 @@
 module Solr
-  VERSION = '0.1.8'.freeze
+  VERSION = '0.1.9'.freeze
 end

data/lib/solr.rb

@@ -9,14 +9,19 @@ require 'solr/document'
 require 'solr/document_collection'
 require 'solr/grouped_document_collection'
 require 'solr/response'
+require 'solr/request/runner'
 require 'solr/query/request'
 require 'solr/indexing/document'
 require 'solr/indexing/request'
-require 'solr/delete/request'
-require 'solr/commit/request'
+
+require 'solr/cloud/helper_methods'
+require 'solr/commands'
 
 module Solr
   class << self
+    include Solr::Commands
+    include Solr::Cloud::HelperMethods
+
     CURRENT_CORE_CONFIG_VARIABLE_NAME = :solrb_current_core_config
 
     attr_accessor :configuration
@@ -25,24 +30,15 @@ module Solr
 
     def configure
       yield configuration
+      configuration.validate!
+      enable_solr_cloud! unless configuration.zookeeper_url.nil?
+      configuration
     end
 
     def current_core_config
       Thread.current[CURRENT_CORE_CONFIG_VARIABLE_NAME] || Solr.configuration.default_core_config
     end
 
-    def commit
-      Solr::Commit::Request.new.run
-    end
-
-    def delete_by_id(id, commit: false)
-      Solr::Delete::Request.new(id: id).run(commit: commit)
-    end
-
-    def delete_by_query(query, commit: false)
-      Solr::Delete::Request.new(query: query).run(commit: commit)
-    end
-
     def with_core(core)
       core_config = Solr.configuration.core_config_by_name(core)
       old_core_config = Thread.current[CURRENT_CORE_CONFIG_VARIABLE_NAME]
@@ -52,9 +48,15 @@ module Solr
       Thread.current[CURRENT_CORE_CONFIG_VARIABLE_NAME] = old_core_config
     end
 
+    def solr_url(path = '')
+      Solr::Support::UrlHelper.solr_url(path)
+    end
+
     def instrument(name:, data: {})
       if defined? ActiveSupport::Notifications
-        ActiveSupport::Notifications.instrument(name, data) do
+        # Create a copy of data to avoid modifications on the original object by rails
+        # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/notifications.rb#L66-L70
+        ActiveSupport::Notifications.instrument(name, data.dup) do
           yield if block_given?
         end
       else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solrb
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Adriano Luz
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-30 00:00:00.000000000 Z
+date: 2019-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -166,7 +166,6 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".ruby-version"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -175,6 +174,11 @@ files:
 - bin/console
 - bin/setup
 - lib/solr.rb
+- lib/solr/cloud/collections_state_manager.rb
+- lib/solr/cloud/configuration.rb
+- lib/solr/cloud/helper_methods.rb
+- lib/solr/cloud/zookeeper_connection.rb
+- lib/solr/commands.rb
 - lib/solr/commit/request.rb
 - lib/solr/configuration.rb
 - lib/solr/connection.rb
@@ -182,15 +186,22 @@ files:
 - lib/solr/core_configuration/core_config_builder.rb
 - lib/solr/core_configuration/dynamic_field.rb
 - lib/solr/core_configuration/field.rb
+- lib/solr/data_import/request.rb
 - lib/solr/delete/request.rb
 - lib/solr/document.rb
 - lib/solr/document_collection.rb
 - lib/solr/errors/ambiguous_core_error.rb
+- lib/solr/errors/could_not_infer_implicit_core_name.rb
+- lib/solr/errors/no_active_solr_nodes_error.rb
+- lib/solr/errors/solr_connection_failed_error.rb
 - lib/solr/errors/solr_query_error.rb
 - lib/solr/errors/solr_url_not_defined_error.rb
+- lib/solr/errors/zookeeper_required.rb
 - lib/solr/grouped_document_collection.rb
 - lib/solr/indexing/document.rb
 - lib/solr/indexing/request.rb
+- lib/solr/query/handler.rb
+- lib/solr/query/http_request_builder.rb
 - lib/solr/query/request.rb
 - lib/solr/query/request/and_filter.rb
 - lib/solr/query/request/boost_magnitude.rb
@@ -214,7 +225,6 @@ files:
 - lib/solr/query/request/geo_filter.rb
 - lib/solr/query/request/grouping.rb
 - lib/solr/query/request/or_filter.rb
-- lib/solr/query/request/runner.rb
 - lib/solr/query/request/sorting.rb
 - lib/solr/query/request/sorting/field.rb
 - lib/solr/query/request/sorting/function.rb
@@ -224,6 +234,10 @@ files:
 - lib/solr/query/response/field_facets.rb
 - lib/solr/query/response/parser.rb
 - lib/solr/query/response/spellcheck.rb
+- lib/solr/request/default_node_selection_strategy.rb
+- lib/solr/request/first_shard_leader_node_selection_strategy.rb
+- lib/solr/request/http_request.rb
+- lib/solr/request/runner.rb
 - lib/solr/response.rb
 - lib/solr/response/header.rb
 - lib/solr/response/http_status.rb
@@ -258,7 +272,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: Solr Ruby client with a nice object-oriented API

data/.ruby-version

@@ -1 +0,0 @@
-2.5.3

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

@@ -1,44 +0,0 @@
-module Solr
-  module Query
-    class Request
-      class Runner
-        PATH = '/select'.freeze
-
-        include Solr::Support::ConnectionHelper
-
-        attr_reader :page, :page_size, :solr_params
-
-        class << self
-          def run(opts)
-            new(opts).run
-          end
-        end
-
-        def initialize(page:, page_size:, solr_params: {})
-          @page = page
-          @page_size = page_size
-          @solr_params = solr_params
-        end
-
-        def run
-          raw_response = connection(PATH).post_as_json(request_params)
-          response = Solr::Response.from_raw_response(raw_response)
-          response
-        end
-
-        private
-
-        def start
-          start_page = @page.to_i - 1
-          start_page = start_page < 1 ? 0 : start_page
-          start_page * page_size
-        end
-
-        def request_params
-          # https://lucene.apache.org/solr/guide/7_1/json-request-api.html#passing-parameters-via-json
-          @request_params ||= { params: solr_params.merge(wt: :json, rows: page_size.to_i, start: start) }
-        end
-      end
-    end
-  end
-end