algoliasearch 1.3.1 → 1.4.0

data/lib/algolia/client.rb

@@ -10,7 +10,7 @@ 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, :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
 
 
     def initialize(data = {})
@@ -18,7 +18,8 @@ module Algolia
       @ssl_version     = data[:ssl_version].nil? ? nil : data[:ssl_version]
       @application_id  = data[:application_id]
       @api_key         = data[:api_key]
-      @hosts           = (data[:hosts] || 1.upto(3).map { |i| "#{@application_id}-#{i}.algolia.net" }).shuffle
+      @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]
@@ -35,9 +36,9 @@ 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)
+    def request(uri, method, data = nil, timeout = nil, read = false)
       exceptions = []
-      thread_local_hosts(timeout).each do |host|
+      thread_local_hosts(read, timeout).each do |host|
         begin
           return perform_request(host[:session], host[:base_url] + uri, method, data)
         rescue AlgoliaProtocolError => e
@@ -50,35 +51,36 @@ module Algolia
       raise AlgoliaProtocolError.new(0, "Cannot reach any host: #{exceptions.map { |e| e.to_s }.join(', ')}")
     end
 
-    def get(uri, timeout = nil)
-      request(uri, :GET, nil, timeout)
+    def get(uri, timeout = nil, read = false)
+      request(uri, :GET, nil, timeout, read)
     end
 
-    def post(uri, body = {}, timeout = nil)
-      request(uri, :POST, body, timeout)
+    def post(uri, body = {}, timeout = nil, read = false)
+      request(uri, :POST, body, timeout, read)
     end
 
-    def put(uri, body = {}, timeout = nil)
-      request(uri, :PUT, body, timeout)
+    def put(uri, body = {}, timeout = nil, read = false)
+      request(uri, :PUT, body, timeout, read)
     end
 
-    def delete(uri, timeout = nil)
-      request(uri, :DELETE, nil, timeout)
+    def delete(uri, timeout = nil, read = false)
+      request(uri, :DELETE, nil, timeout, read)
     end
 
     private
 
     # This method returns a thread-local array of sessions
-    # 
+    #
     # Since the underlying httpclient library resets the connections pool
     # 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(forced_timeout)
-      Thread.current[:algolia_hosts] ||= {}
-      Thread.current[:algolia_hosts][forced_timeout.to_s] ||= hosts.map do |host|
+    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|
         client = HTTPClient.new
-        client.ssl_config.ssl_version = @ssl_version if @ssl && @ssl_version        
+        client.ssl_config.ssl_version = @ssl_version if @ssl && @ssl_version
         hinfo = {
           :base_url => "http#{@ssl ? 's' : ''}://#{host}",
           :session => client
@@ -208,7 +210,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)
+    Algolia.client.post(Protocol.multiple_queries_uri, requests.to_json, Algolia.client.search_timeout, true)
   end
 
   #
@@ -281,8 +283,15 @@ module Algolia
   # @param offset Specify the first entry to retrieve (0-based, 0 is the most recent log entry).
   # @param length Specify the maximum number of entries to retrieve starting at offset. Maximum allowed value: 1000.
   #
-  def Algolia.get_logs(offset = 0, length = 10, only_errors = false)
-      Algolia.client.get(Protocol.logs(offset, length, only_errors))
+  def Algolia.get_logs(offset = 0, length = 10, type = "all")
+      if (type.is_a?(true.class))
+        if (type)
+          type = "error"
+        else
+          type = "all"
+        end
+      end
+      Algolia.client.get(Protocol.logs(offset, length, type))
   end
 
   # List all existing user keys with their associated ACLs
@@ -359,7 +368,7 @@ module Algolia
 
   # Used mostly for testing. Lets you delete the api key global vars.
   def Algolia.destroy
-    @@client = Thread.current[:algolia_hosts] = nil
+    @@client = Thread.current[:algolia_hosts] = Thread.current[:algolia_search_hosts] = nil
     self
   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)
+      Algolia.client.get(Protocol.search_uri(name, query, encoded_params), Algolia.client.search_timeout, true)
     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.get(Protocol.object_uri(name, objectID, nil), Algolia.client.search_timeout, true)
       else
-        Algolia.client.get(Protocol.object_uri(name, objectID, {:attributes => attributesToRetrieve}))
+        Algolia.client.get(Protocol.object_uri(name, objectID, {:attributes => attributesToRetrieve}), Algolia.client.search_timeout, true)
       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)['results']
+      Algolia.client.post(Protocol.objects_uri, { :requests => objectIDs.map { |objectID| { :indexName => name, :objectID => objectID } } }.to_json, Algolia.client.search_timeout, true)['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))["status"]
+        status = Algolia.client.get(Protocol.task_uri(name, taskID), nil, true)["status"]
         if status == "published"
           return
         end
@@ -540,7 +540,8 @@ module Algolia
           :attributesToHighlight => [],
           :attributesToSnippet => [],
           :facets => disjunctive_facet,
-          :facetFilters => filters
+          :facetFilters => filters,
+          :analytics => false
         })
       end
       answers = Algolia.multiple_queries(queries)

data/lib/algolia/version.rb

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

data/lib/algolia/webmock.rb

@@ -11,7 +11,7 @@ WebMock.disable!
 # list indexes
 WebMock.stub_request(:get, /.*\.algolia\.(io|net)\/1\/indexes/).to_return(:body => '{ "items": [] }')
 # query index
-WebMock.stub_request(:get, /.*\.algolia\.(io|net)\/1\/indexes\/[^\/]+/).to_return(:body => '{}')
+WebMock.stub_request(:get, /.*\.algolia\.(io|net)\/1\/indexes\/[^\/]+/).to_return(:body => '{ "hits": [ { "objectID": 42 } ], "page": 1, "hitsPerPage": 1 }')
 WebMock.stub_request(:post, /.*\.algolia\.(io|net)\/1\/indexes\/[^\/]+\/query/).to_return(:body => '{}')
 # delete index
 WebMock.stub_request(:delete, /.*\.algolia\.(io|net)\/1\/indexes\/[^\/]+/).to_return(:body => '{ "taskID": 42 }')

data/spec/client_spec.rb

@@ -262,7 +262,7 @@ describe 'Client' do
   end 
 
   it "should get logs" do
-    res = Algolia.get_logs
+    res = Algolia.get_logs(0, 20, true)
 
     res['logs'].size.should > 0
   end
@@ -719,5 +719,23 @@ describe 'Client' do
     answer['disjunctiveFacets']['stars']['*'].should eq(2)
     answer['disjunctiveFacets']['stars']['****'].should eq(1)
   end
+
+  it 'should apply jobs one after another if synchronous' do
+    index = Algolia::Index.new(safe_index_name("sync"))
+    begin
+      index.add_object! :objectID => 1
+      answer = index.search('')
+      answer['nbHits'].should eq(1)
+      answer['hits'][0]['objectID'].to_i.should eq(1)
+      index.clear_index!
+      index.add_object! :objectID => 2
+      index.add_object! :objectID => 3
+      answer = index.search('')
+      answer['nbHits'].should eq(2)
+      answer['hits'][0]['objectID'].to_i.should_not eq(1)
+    ensure
+      index.delete_index
+    end
+  end
 end
 

data/spec/mock_spec.rb

@@ -6,13 +6,13 @@ describe 'With a mocked client' do
 
   before(:each) do
     WebMock.enable!
-    Thread.current[:algolia_hosts] = nil # reset session objects
+    Thread.current[:algolia_hosts] = Thread.current[:algolia_search_hosts] = nil # reset session objects
   end
 
   it "should add a simple object" do
     index = Algolia::Index.new("friends")
     index.add_object!({ :name => "John Doe", :email => "john@doe.org" })
-    index.search('').should == {} # mocked
+    index.search('').should == { "hits" => [ { "objectID" => 42 } ], "page" => 1, "hitsPerPage" => 1 } # mocked
     index.list_user_keys
     index.browse
     index.clear

data/spec/stub_spec.rb

@@ -6,7 +6,7 @@ describe 'With a rate limited client' do
 
   before(:each) do
     WebMock.enable!
-    Thread.current[:algolia_hosts] = nil
+    Thread.current[:algolia_hosts] = Thread.current[:algolia_search_hosts] = nil
   end
 
   it "should pass the right headers" do

metadata

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