algoliasearch 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60f96e5a2607dcefc2d61bfd860ee85334fc4974
-  data.tar.gz: 13a0e314c0fb5df77b4189030e6505e76a7f8924
+  metadata.gz: d9df8ced9c8a5da4e7e677c2643b24891b84a406
+  data.tar.gz: ea2d150a9d5171f5e4da18a6a5c7758137d31aa5
 SHA512:
-  metadata.gz: 84e2f40e68e6a1114196025eba308416ddcf6156d4bec2bf99cba69a5d0420d279c0d1294df2200eb07c6dc5d0749d3ff943f1c17f80ed62e707799e20dcb796
-  data.tar.gz: b2fd8567ef442cd5b987a684fb56a5c83d5b753034a62dffdc551b16a69862ea92d733a95eda3ddf532d2b99105ea8761c48a86e48e8f9fb57a8d58617cef635
+  metadata.gz: 04a47d4b5227e7e97db5d33fb1759a3c053e0e34a94fb6d7eb380c97a4ae4dbfc097df30755afa2524f41cc93400d19c2b3db5d70676cd9a5469ba68cadab3e4
+  data.tar.gz: 088ba592a94f6e31dd3d0f07f5668b53bb63932fd8680e84c03da0dc7a0add25aaa8a8bfca3f8c9b43ec797d0288391611ec441f89d0bfa77a188de3ffbfdbd8

data/ChangeLog

@@ -1,5 +1,8 @@
 CHANGELOG
 
+2015-04-10  1.4.1
+      * Force the default connect/read/write/search/batch timeouts to Algolia-specific values
+
 2015-03-17  1.4.0
       * High-available DNS: search queries are now targeting "APPID-DSN.algolia.net" first, then the main cluster using NSOne, then the main cluster using Route53.
         Indexing queries are targeting "APPID.algolia.net" first, then the main cluster using NSOne, then the main cluster using Route53.

data/README.md

@@ -3,21 +3,8 @@
 
 
 [Algolia Search](http://www.algolia.com) is a hosted full-text, numerical, and faceted search engine capable of delivering realtime results from the first keystroke.
-Algolia's Search API makes it easy to deliver a great search experience in your websites and mobile applications by providing:
 
- * REST and JSON based API
- * Search against infinite attributes from a single search box
- * Instant search as you type experience
- * Relevance and popularity ranking
- * Global language support
- * Typo tolerance in any language
- * Smart highlighting
- * Facet as you type
- * Geo awareness
- * 99.99% SLA
- * First class data security
-
-Our Ruby client lets you easily use the [Algolia Search API](http://www.algolia.com) from your backend. It wraps the [Algolia Search REST API](http://www.algolia.com/doc/rest_api).
+Our Ruby client lets you easily use the [Algolia Search API](https://www.algolia.com/doc/rest_api) from your backend. It wraps the [Algolia Search REST API](http://www.algolia.com/doc/rest_api).
 
 
 [![Build Status](https://travis-ci.org/algolia/algoliasearch-client-ruby.svg?branch=master)](https://travis-ci.org/algolia/algoliasearch-client-ruby) [![Gem Version](https://badge.fury.io/rb/algoliasearch.svg)](http://badge.fury.io/rb/algoliasearch) [![Code Climate](https://codeclimate.com/github/algolia/algoliasearch-client-ruby.svg)](https://codeclimate.com/github/algolia/algoliasearch-client-ruby) [![Coverage Status](https://coveralls.io/repos/algolia/algoliasearch-client-ruby/badge.png)](https://coveralls.io/r/algolia/algoliasearch-client-ruby)
@@ -131,25 +118,35 @@ puts index.search('jim').to_json
 
 **Notes:** If you are building a web application, you may be more interested in using our [JavaScript client](https://github.com/algolia/algoliasearch-client-js) to perform queries. It brings two benefits:
   * Your users get a better response time by not going through your servers
-  * It will offload unnecessary tasks from your servers.
+  * It will offload unnecessary tasks from your servers
 
 ```html
-<script type="text/javascript" src="//path/to/algoliasearch.min.js"></script>
-<script type="text/javascript">
-  var client = new AlgoliaSearch("YourApplicationID", "YourSearchOnlyAPIKey");
-  var index = client.initIndex('YourIndexName');
-
-  function searchCallback(success, content) {
-    if (success) {
-      console.log(content);
-    }
+<script src="//cdn.jsdelivr.net/algoliasearch/3/algoliasearch.min.js"></script>
+<script>
+var client = algoliasearch('ApplicationID', 'Search-Only-API-Key');
+var index = client.initIndex('indexName');
+
+// perform query "jim"
+index.search('jim', searchCallback);
+
+// the last optional argument can be used to add search parameters
+index.search(
+  'jim', {
+    hitsPerPage: 5,
+    facets: '*',
+    maxValuesPerFacet: 10
+  },
+  searchCallback
+);
+
+function searchCallback(err, content) {
+  if (err) {
+    console.error(err);
+    return;
   }
 
-  // perform query "jim"
-  index.search("jim", searchCallback);
-
-  // the last optional argument can be used to add search parameters
-  index.search("jim", searchCallback, { hitsPerPage: 5, facets: '*', maxValuesPerFacet: 10 });
+  console.log(content);
+}
 </script>
 ```
 
@@ -390,7 +387,7 @@ res = index.search("query string", { "attributesToRetrieve" => "firstname,lastna
 
 The server response will look like:
 
-```javascript
+```json
 {
   "hits": [
     {
@@ -458,6 +455,7 @@ res = index.get_object("myID", "fistname")
 
 You can also retrieve a set of objects:
 
+
 ```ruby
 res = index.get_objects(["myID", "myID2"])
 ```
@@ -466,6 +464,7 @@ res = index.get_objects(["myID", "myID2"])
 
 
 
+
 Delete an object
 -------------
 
@@ -740,15 +739,23 @@ You may have a single index containing per user data. In that case, all records
 public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', '(public,user_42)'
 ```
 
-This public API key must then be used in your JavaScript code as follow:
+This public API key can then be used in your JavaScript code as follow:
 
 ```javascript
 <script type="text/javascript">
-  var algolia = new AlgoliaSearch('YourApplicationID', '<%= public_api_key %>');
-  algolia.setSecurityTags('(public,user_42)'); // must be same than those used at generation-time
-  algolia.initIndex('YourIndex').search($('#q').val(), function(success, content) {
-    // [...]
-  });
+var client = algoliasearch('YourApplicationID', '<%= public_api_key %>');
+client.setSecurityTags('(public,user_42)'); // must be same than those used at generation-time
+
+var index = client.initIndex('indexName')
+
+index.search('something', function(err, content) {
+  if (err) {
+    console.error(err);
+    return;
+  }
+
+  console.log(content);
+});
 </script>
 ```
 
@@ -761,16 +768,28 @@ You can mix rate limits and secured API keys by setting an extra `user_token` at
 public_key = Algolia.generate_secured_api_key 'YourRateLimitedApiKey', '(public,user_42)', 'user_42'
 ```
 
-This public API key must then be used in your JavaScript code as follow:
+This public API key can then be used in your JavaScript code as follow:
 
 ```javascript
 <script type="text/javascript">
-  var algolia = new AlgoliaSearch('YourApplicationID', '<%= public_api_key %>');
-  algolia.setSecurityTags('(public,user_42)'); // must be same than those used at generation-time
-  algolia.setUserToken('user_42')              // must be same than the one used at generation-time
-  algolia.initIndex('YourIndex').search($('#q').val(), function(success, content) {
-    // [...]
-  });
+var client = algoliasearch('YourApplicationID', '<%= public_api_key %>');
+
+// must be same than those used at generation-time
+client.setSecurityTags('(public,user_42)');
+
+// must be same than the one used at generation-time
+client.setUserToken('user_42');
+
+var index = client.initIndex('indexName')
+
+index.search('another query', function(err, content) {
+  if (err) {
+    console.error(err);
+    return;
+  }
+
+  console.log(content);
+});
 </script>
 ```
 

data/lib/algolia/client.rb

@@ -10,20 +10,26 @@ module Algolia
   # A class which encapsulates the HTTPS communication with the Algolia
   # API server. Uses the HTTPClient library for low-level HTTP communication.
   class Client
-    attr_reader :ssl, :ssl_version, :hosts, :search_hosts, :application_id, :api_key, :headers, :connect_timeout, :send_timeout, :receive_timeout, :search_timeout
+    attr_reader :ssl, :ssl_version, :hosts, :search_hosts, :application_id, :api_key, :headers, :connect_timeout, :send_timeout, :receive_timeout, :search_timeout, :batch_timeout
 
+    DEFAULT_CONNECT_TIMEOUT = 2
+    DEFAULT_RECEIVE_TIMEOUT = 30
+    DEFAULT_SEND_TIMEOUT    = 30
+    DEFAULT_BATCH_TIMEOUT   = 120
+    DEFAULT_SEARCH_TIMEOUT  = 5
 
     def initialize(data = {})
       @ssl             = data[:ssl].nil? ? true : data[:ssl]
       @ssl_version     = data[:ssl_version].nil? ? nil : data[:ssl_version]
       @application_id  = data[:application_id]
       @api_key         = data[:api_key]
-      @hosts           = data[:hosts] || (["#{@application_id}.algolia.net"] + 1.upto(3).map { |i| "#{@application_id}-#{i}.algolia.net" }.shuffle + 1.upto(3).map { |i| "#{@application_id}-#{i}.algolianet.com" }.shuffle)
-      @search_hosts    = data[:search_hosts] || (["#{@application_id}-dsn.algolia.net"] + 1.upto(3).map { |i| "#{@application_id}-#{i}.algolia.net" }.shuffle + 1.upto(3).map { |i| "#{@application_id}-#{i}.algolianet.com" }.shuffle)
-      @connect_timeout = data[:connect_timeout]
-      @send_timeout    = data[:send_timeout]
-      @receive_timeout = data[:receive_timeout]
-      @search_timeout  = data[:search_timeout]
+      @hosts           = data[:hosts] || (["#{@application_id}.algolia.net"] + 1.upto(3).map { |i| "#{@application_id}-#{i}.algolianet.com" }.shuffle)
+      @search_hosts    = data[:search_hosts] || data[:hosts] || (["#{@application_id}-dsn.algolia.net"] + 1.upto(3).map { |i| "#{@application_id}-#{i}.algolianet.com" }.shuffle)
+      @connect_timeout = data[:connect_timeout] || DEFAULT_CONNECT_TIMEOUT
+      @send_timeout    = data[:send_timeout] || DEFAULT_SEND_TIMEOUT
+      @batch_timeout   = data[:batch_timeout] || DEFAULT_BATCH_TIMEOUT
+      @receive_timeout = data[:receive_timeout] || DEFAULT_RECEIVE_TIMEOUT
+      @search_timeout  = data[:search_timeout] || DEFAULT_SEARCH_TIMEOUT
       @headers = {
         Protocol::HEADER_API_KEY => api_key,
         Protocol::HEADER_APP_ID  => application_id,
@@ -36,9 +42,26 @@ module Algolia
     # with common basic response handling. Will raise a
     # AlgoliaProtocolError if the response has an error status code,
     # and will return the parsed JSON body on success, if there is one.
-    def request(uri, method, data = nil, timeout = nil, read = false)
+    def request(uri, method, data = nil, type = :write)
       exceptions = []
-      thread_local_hosts(read, timeout).each do |host|
+
+      connect_timeout = @connect_timeout
+      send_timeout = if type == :search
+        @search_timeout
+      elsif type == :batch
+        type = :write
+        @batch_timeout
+      else
+        @send_timeout
+      end
+      receive_timeout = type == :search ? @search_timeout : @receive_timeout
+
+      (type == :write ? @hosts : @search_hosts).size.times do |i|
+        connect_timeout += 2 if i == 2
+        send_timeout += 10 if i == 2
+        receive_timeout += 10 if i == 2
+
+        host = thread_local_hosts(type != :write, connect_timeout, send_timeout, receive_timeout)[i]
         begin
           return perform_request(host[:session], host[:base_url] + uri, method, data)
         rescue AlgoliaProtocolError => e
@@ -51,20 +74,20 @@ module Algolia
       raise AlgoliaProtocolError.new(0, "Cannot reach any host: #{exceptions.map { |e| e.to_s }.join(', ')}")
     end
 
-    def get(uri, timeout = nil, read = false)
-      request(uri, :GET, nil, timeout, read)
+    def get(uri, type = :write)
+      request(uri, :GET, nil, type)
     end
 
-    def post(uri, body = {}, timeout = nil, read = false)
-      request(uri, :POST, body, timeout, read)
+    def post(uri, body = {}, type = :write)
+      request(uri, :POST, body, type)
     end
 
-    def put(uri, body = {}, timeout = nil, read = false)
-      request(uri, :PUT, body, timeout, read)
+    def put(uri, body = {}, type = :write)
+      request(uri, :PUT, body, type)
     end
 
-    def delete(uri, timeout = nil, read = false)
-      request(uri, :DELETE, nil, timeout, read)
+    def delete(uri, type = :write)
+      request(uri, :DELETE, nil, type)
     end
 
     private
@@ -75,10 +98,10 @@ module Algolia
     # if you change any of its attributes, we cannot change the timeout
     # of an HTTP session dynamically. That being said, having 1 pool per
     # timeout appears to be the only acceptable solution
-    def thread_local_hosts(read, forced_timeout)
-      k = read ? :algolia_search_hosts : :algolia_hosts
-      Thread.current[k] ||= {}
-      Thread.current[k][forced_timeout.to_s] ||= (read ? search_hosts : hosts).map do |host|
+    def thread_local_hosts(read, connect_timeout, send_timeout, receive_timeout)
+      thread_local_var = read ? :algolia_search_hosts : :algolia_hosts
+      Thread.current[thread_local_var] ||= {}
+      Thread.current[thread_local_var]["#{connect_timeout}-#{send_timeout}-#{receive_timeout}"] ||= (read ? search_hosts : hosts).map do |host|
         client = HTTPClient.new
         client.ssl_config.ssl_version = @ssl_version if @ssl && @ssl_version
         hinfo = {
@@ -86,13 +109,9 @@ module Algolia
           :session => client
         }
         hinfo[:session].transparent_gzip_decompression = true
-        hinfo[:session].connect_timeout = @connect_timeout if @connect_timeout
-        if forced_timeout
-          hinfo[:session].send_timeout = hinfo[:session].receive_timeout = forced_timeout
-        else
-          hinfo[:session].send_timeout = @send_timeout if @send_timeout
-          hinfo[:session].receive_timeout = @receive_timeout if @receive_timeout
-        end
+        hinfo[:session].connect_timeout = connect_timeout
+        hinfo[:session].send_timeout = send_timeout
+        hinfo[:session].receive_timeout = receive_timeout
         hinfo[:session].ssl_config.add_trust_ca File.join(File.dirname(__FILE__), '..', '..', 'resources', 'ca-bundle.crt')
         hinfo
       end
@@ -210,7 +229,7 @@ module Algolia
         { :indexName => indexName, :params => Protocol.to_query(encoded_params) }
       end
     }
-    Algolia.client.post(Protocol.multiple_queries_uri, requests.to_json, Algolia.client.search_timeout, true)
+    Algolia.client.post(Protocol.multiple_queries_uri, requests.to_json, :search)
   end
 
   #
@@ -220,7 +239,7 @@ module Algolia
   #                {"name": "notes", "createdAt": "2013-01-18T15:33:13.556Z"}]}
   #
   def Algolia.list_indexes
-      Algolia.client.get(Protocol.indexes_uri)
+      Algolia.client.get(Protocol.indexes_uri, :read)
   end
 
   #
@@ -296,12 +315,12 @@ module Algolia
 
   # List all existing user keys with their associated ACLs
   def Algolia.list_user_keys
-      Algolia.client.get(Protocol.keys_uri)
+      Algolia.client.get(Protocol.keys_uri, :read)
   end
 
   # Get ACL of a user key
   def Algolia.get_user_key(key)
-      Algolia.client.get(Protocol.key_uri(key))
+      Algolia.client.get(Protocol.key_uri(key), :read)
   end
 
   #

data/lib/algolia/index.rb

@@ -136,7 +136,7 @@ module Algolia
     #   one is kept and others are removed.
     def search(query, params = {})
       encoded_params = Hash[params.map { |k,v| [k.to_s, v.is_a?(Array) ? v.to_json : v] }]
-      Algolia.client.get(Protocol.search_uri(name, query, encoded_params), Algolia.client.search_timeout, true)
+      Algolia.client.get(Protocol.search_uri(name, query, encoded_params), :search)
     end
 
     #
@@ -147,7 +147,7 @@ module Algolia
     # @param hitsPerPage: Pagination parameter used to select the number of hits per page. Defaults to 1000.
     #
     def browse(page = 0, hitsPerPage = 1000)
-     Algolia.client.get(Protocol.browse_uri(name, {:page => page, :hitsPerPage => hitsPerPage}))
+     Algolia.client.get(Protocol.browse_uri(name, {:page => page, :hitsPerPage => hitsPerPage}), :read)
     end
 
     #
@@ -158,9 +158,9 @@ module Algolia
     #
     def get_object(objectID, attributesToRetrieve = nil)
       if attributesToRetrieve.nil?
-        Algolia.client.get(Protocol.object_uri(name, objectID, nil), Algolia.client.search_timeout, true)
+        Algolia.client.get(Protocol.object_uri(name, objectID, nil), :read)
       else
-        Algolia.client.get(Protocol.object_uri(name, objectID, {:attributes => attributesToRetrieve}), Algolia.client.search_timeout, true)
+        Algolia.client.get(Protocol.object_uri(name, objectID, {:attributes => attributesToRetrieve}), :read)
       end
     end
 
@@ -170,7 +170,7 @@ module Algolia
     # @param objectIDs the array of unique identifier of the objects to retrieve
     #
     def get_objects(objectIDs)
-      Algolia.client.post(Protocol.objects_uri, { :requests => objectIDs.map { |objectID| { :indexName => name, :objectID => objectID } } }.to_json, Algolia.client.search_timeout, true)['results']
+      Algolia.client.post(Protocol.objects_uri, { :requests => objectIDs.map { |objectID| { :indexName => name, :objectID => objectID } } }.to_json, :read)['results']
     end
 
     # Wait the publication of a task on the server. 
@@ -181,7 +181,7 @@ module Algolia
     #    
     def wait_task(taskID, timeBeforeRetry = 100)
       loop do
-        status = Algolia.client.get(Protocol.task_uri(name, taskID), nil, true)["status"]
+        status = Algolia.client.get(Protocol.task_uri(name, taskID), :read)["status"]
         if status == "published"
           return
         end
@@ -416,17 +416,17 @@ module Algolia
     
     # Get settings of this index
     def get_settings
-      Algolia.client.get(Protocol.settings_uri(name))
+      Algolia.client.get(Protocol.settings_uri(name), :read)
     end 
 
     # List all existing user keys with their associated ACLs
     def list_user_keys
-      Algolia.client.get(Protocol.index_keys_uri(name))
+      Algolia.client.get(Protocol.index_keys_uri(name), :read)
     end
  
     # Get ACL of a user key
     def get_user_key(key)
-      Algolia.client.get(Protocol.index_key_uri(name, key))
+      Algolia.client.get(Protocol.index_key_uri(name, key), :read)
     end
  
     #
@@ -473,7 +473,7 @@ module Algolia
 
     # Send a batch request
     def batch(request)
-      Algolia.client.post(Protocol.batch_uri(name), request.to_json)
+      Algolia.client.post(Protocol.batch_uri(name), request.to_json, :batch)
     end
 
     # Send a batch request and wait the end of the indexing

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = "1.4.0"
+  VERSION = "1.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algoliasearch
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Algolia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-17 00:00:00.000000000 Z
+date: 2015-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient