elasticsearch-transport 1.0.16 → 1.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 110c72e9d30c5a91ffd9e8f0910fb1c3bdb5b31c
-  data.tar.gz: 3f39c7af7cfe467c6ef5f755b8410a86898caa4f
+  metadata.gz: 03da4187dfe5748e0a63a03b5311e69a16c300ee
+  data.tar.gz: e5150265f830efda95bf5da80f2fe9e89cd8b98f
 SHA512:
-  metadata.gz: 6b070500608e152cf6a0d43a1a7ea6b7d1fe1b2db2f119e7be2b054a9c65097ef340f090b26e3f4210a231244e292c39db19ade36c34c9f1a0b0de04604fdde9
-  data.tar.gz: b61a1757529a8a82490c90852ca36bee8d3f662e04d40b2b9ffae25c41fab58b991c836786ef1fa327480b606f72ea555c7253153ee7cb07770694a05aafb58e
+  metadata.gz: 1fdb7e4a825042933383ec0fe4bddd3db31996e73f1095cc7c406889bbea887d14827e7c28357b9bf86eaeca4b6995a65f019897c3385f4f9da0b2f2849c364c
+  data.tar.gz: 6281a6bada7e2db9aac41397539cc1ab9aeec92fae134a9286b8461e1b4d05abb6f600a05ffe70325cd377d3c0164df5da118d1b43503b9793faf8404868d82b

data/lib/elasticsearch/transport/transport/base.rb

@@ -18,7 +18,7 @@ module Elasticsearch
                       :reload_connections, :reload_after,
                       :resurrect_after, :max_retries
 
-        # Creates a new transport object.
+        # Creates a new transport object
         #
         # @param arguments [Hash] Settings and options for the transport
         # @param block     [Proc] Lambda or Proc which can be evaluated in the context of the "session" object
@@ -71,7 +71,7 @@ module Elasticsearch
           connections.get_connection(options)
         end
 
-        # Reloads and replaces the connection collection based on cluster information.
+        # Reloads and replaces the connection collection based on cluster information
         #
         # @see Sniffer#hosts
         #
@@ -84,7 +84,7 @@ module Elasticsearch
           self
         end
 
-        # Tries to "resurrect" all eligible dead connections.
+        # Tries to "resurrect" all eligible dead connections
         #
         # @see Connections::Connection#resurrect!
         #
@@ -92,28 +92,74 @@ module Elasticsearch
           connections.dead.each { |c| c.resurrect! }
         end
 
-        # Replaces the connections collection.
+        # Rebuilds the connections collection in the transport.
         #
+        # The methods *adds* new connections from the passed hosts to the collection,
+        # and *removes* all connections not contained in the passed hosts.
+        #
+        # @return [Connections::Collection]
         # @api private
         #
         def __rebuild_connections(arguments={})
           @state_mutex.synchronize do
             @hosts       = arguments[:hosts]    || []
             @options     = arguments[:options]  || {}
+
             __close_connections
-            @connections = __build_connections
+
+            new_connections = __build_connections
+            stale_connections = @connections.select  { |c| ! new_connections.include?(c) }
+            new_connections = new_connections.reject { |c| @connections.include?(c) }
+
+            @connections.remove(stale_connections)
+            @connections.add(new_connections)
+            @connections
           end
         end
 
-        # Closes the connections collection.
+        # Builds and returns a collection of connections
+        #
+        # The adapters have to implement the {Base#__build_connection} method.
+        #
+        # @return [Connections::Collection]
+        # @api    private
+        #
+        def __build_connections
+          Connections::Collection.new \
+            :connections => hosts.map { |host|
+              host[:protocol] = host[:scheme] || options[:scheme] || options[:http][:scheme] || DEFAULT_PROTOCOL
+              host[:port] ||= options[:port] || options[:http][:scheme] || DEFAULT_PORT
+              if (options[:user] || options[:http][:user]) && !host[:user]
+                host[:user] ||= options[:user] || options[:http][:user]
+                host[:password] ||= options[:password] || options[:http][:password]
+              end
+
+              __build_connection(host, (options[:transport_options] || {}), @block)
+            },
+            :selector_class => options[:selector_class],
+            :selector => options[:selector]
+        end
+
+        # @abstract Build and return a connection.
+        #           A transport implementation *must* implement this method.
+        #           See {HTTP::Faraday#__build_connection} for an example.
+        #
+        # @return [Connections::Connection]
+        # @api    private
+        #
+        def __build_connection(host, options={}, block=nil)
+          raise NoMethodError, "Implement this method in your class"
+        end
+
+        # Closes the connections collection
         #
         # @api private
         #
         def __close_connections
-          # to be implemented by specific transports
+          # A hook point for specific adapters when they need to close connections
         end
 
-        # Log request and response information.
+        # Log request and response information
         #
         # @api private
         #
@@ -125,16 +171,18 @@ module Elasticsearch
           logger.debug "< #{response.body}"
         end
 
-        # Log failed request.
+        # Log failed request
         #
         # @api private
+        #
         def __log_failed(response)
           logger.fatal "[#{response.status}] #{response.body}"
         end
 
-        # Trace the request in the `curl` format.
+        # Trace the request in the `curl` format
         #
         # @api private
+        #
         def __trace(method, path, params, body, url, response, json, took, duration)
           trace_url  = "http://localhost:9200/#{path}?pretty" +
                        ( params.empty? ? '' : "&#{::Faraday::Utils::ParamsHash[params].to_query}" )
@@ -147,6 +195,7 @@ module Elasticsearch
         # Raise error specific for the HTTP response status or a generic server error
         #
         # @api private
+        #
         def __raise_transport_error(response)
           error = ERRORS[response.status] || ServerError
           raise error.new "[#{response.status}] #{response.body}"
@@ -155,6 +204,7 @@ module Elasticsearch
         # Converts any non-String object to JSON
         #
         # @api private
+        #
         def __convert_to_json(o=nil, options={})
           o = o.is_a?(String) ? o : serializer.dump(o, options)
         end
@@ -281,15 +331,6 @@ module Elasticsearch
         def host_unreachable_exceptions
           [Errno::ECONNREFUSED]
         end
-
-        # @abstract A transport implementation must implement this method.
-        #           See {HTTP::Faraday#__build_connections} for an example.
-        #
-        # @return [Connections::Collection]
-        # @api    private
-        def __build_connections
-          raise NoMethodError, "Implement this method in your class"
-        end
       end
     end
   end

data/lib/elasticsearch/transport/transport/connections/collection.rb

@@ -85,6 +85,26 @@ module Elasticsearch
           def size
             connections.size
           end
+
+          # Add connection(s) to the collection
+          #
+          # @param connections [Connection,Array] A connection or an array of connections to add
+          # @return [self]
+          #
+          def add(connections)
+            @connections += Array(connections).to_a
+            self
+          end
+
+          # Remove connection(s) from the collection
+          #
+          # @param connections [Connection,Array] A connection or an array of connections to remove
+          # @return [self]
+          #
+          def remove(connections)
+            @connections -= Array(connections).to_a
+            self
+          end
         end
 
       end

data/lib/elasticsearch/transport/transport/connections/connection.rb

@@ -118,6 +118,16 @@ module Elasticsearch
             }
           end
 
+          # Equality operator based on connection protocol, host and port
+          #
+          # @return [Boolean]
+          #
+          def ==(other)
+            self.host[:protocol] == other.host[:protocol] && \
+            self.host[:host] == other.host[:host] && \
+            self.host[:port].to_i == other.host[:port].to_i
+          end
+
           # @return [String]
           #
           def to_s

data/lib/elasticsearch/transport/transport/http/curb.rb

@@ -37,32 +37,24 @@ module Elasticsearch
             end
           end
 
-          # Builds and returns a collection of connections.
+          # Builds and returns a connection
           #
-          # @return [Connections::Collection]
+          # @return [Connections::Connection]
           #
-          def __build_connections
-            Connections::Collection.new \
-              :connections => hosts.map { |host|
-                host[:protocol]   = host[:scheme] || DEFAULT_PROTOCOL
-                host[:port]     ||= DEFAULT_PORT
+          def __build_connection(host, options={}, block=nil)
+            client = ::Curl::Easy.new
+            client.headers = {'User-Agent' => "Curb #{Curl::CURB_VERSION}"}
+            client.url     = __full_url(host)
 
-                client = ::Curl::Easy.new
-                client.headers      = {'User-Agent' => "Curb #{Curl::CURB_VERSION}"}
-                client.url          = __full_url(host)
-
-                if host[:user]
-                  client.http_auth_types = host[:auth_type] || :basic
-                  client.username = host[:user]
-                  client.password = host[:password]
-                end
+            if host[:user]
+              client.http_auth_types = host[:auth_type] || :basic
+              client.username = host[:user]
+              client.password = host[:password]
+            end
 
-                client.instance_eval(&@block) if @block
+            client.instance_eval(&block) if block
 
-                Connections::Connection.new :host => host, :connection => client
-              },
-              :selector_class => options[:selector_class],
-              :selector => options[:selector]
+            Connections::Connection.new :host => host, :connection => client
           end
 
           # Returns an array of implementation specific connection errors.

data/lib/elasticsearch/transport/transport/http/faraday.rb

@@ -27,28 +27,13 @@ module Elasticsearch
             end
           end
 
-          # Builds and returns a collection of connections.
+          # Builds and returns a connection
           #
-          # @return [Connections::Collection]
+          # @return [Connections::Connection]
           #
-          def __build_connections
-            Connections::Collection.new \
-              :connections => hosts.map { |host|
-                host[:protocol] = host[:scheme] || options[:scheme] || options[:http][:scheme] || DEFAULT_PROTOCOL
-                host[:port] ||= options[:port] || options[:http][:scheme] || DEFAULT_PORT
-                if (options[:user] || options[:http][:user]) && !host[:user]
-                  host[:user] ||= options[:user] || options[:http][:user]
-                  host[:password] ||= options[:password] || options[:http][:password]
-                end
-
-                url = __full_url(host)
-
-                Connections::Connection.new \
-                  :host => host,
-                  :connection => ::Faraday::Connection.new(url, (options[:transport_options] || {}), &@block )
-              },
-              :selector_class => options[:selector_class],
-              :selector => options[:selector]
+          def __build_connection(host, options={}, block=nil)
+            client = ::Faraday::Connection.new(__full_url(host), options, &block)
+            Connections::Connection.new :host => host, :connection => client
           end
 
           # Returns an array of implementation specific connection errors.

data/lib/elasticsearch/transport/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Transport
-    VERSION = "1.0.16"
+    VERSION = "1.0.17"
   end
 end

data/test/integration/client_test.rb

@@ -12,7 +12,6 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
   context "Elasticsearch client" do
     teardown do
       begin; Object.send(:remove_const, :Typhoeus);                rescue NameError; end
-      begin; Object.send(:remove_const, :Patron);                  rescue NameError; end
       begin; Net::HTTP.send(:remove_const, :Persistent); rescue NameError; end
     end
 
@@ -168,6 +167,27 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
       end
     end
 
+    context "when reloading connections" do
+      should "keep existing connections" do
+        require 'patron' # We need a client with keep-alive
+        client = Elasticsearch::Transport::Client.new host: "localhost:#{@port}", adapter: :patron, logger: @logger
+
+        assert_equal 'Faraday::Adapter::Patron',
+                      client.transport.connections.first.connection.builder.handlers.first.name
+
+        response = client.perform_request 'GET', '_nodes/stats/http'
+
+        a = response.body['nodes'].values.select { |n| n['name'] == 'node-1' }.first['http']['total_opened']
+
+        client.transport.reload_connections!
+
+        response = client.perform_request 'GET', '_nodes/stats/http'
+        b = response.body['nodes'].values.select { |n| n['name'] == 'node-1' }.first['http']['total_opened']
+
+        assert_equal a, b
+      end unless JRUBY
+    end
+
     context "with Faraday adapters" do
       should "set the adapter with a block" do
         require 'net/http/persistent'
@@ -184,6 +204,8 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
       end
 
       should "automatically use the Patron client when loaded" do
+        teardown { begin; Object.send(:remove_const, :Patron); rescue NameError; end }
+
         require 'patron'
         client = Elasticsearch::Transport::Client.new host: "localhost:#{@port}"
 

data/test/unit/connection_collection_test.rb

@@ -43,6 +43,48 @@ class Elasticsearch::Transport::Transport::Connections::CollectionTest < Test::U
       assert_equal  2,             c.size
     end
 
+    should "add connections" do
+      c = Collection.new :connections => [ Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 1}) ]
+      assert_equal 1, c.size
+
+      c.add([ Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 1 }),
+              Connection.new(:host => { :protocol => 'http', :host => 'bam', :port => 1 }) ])
+      assert_equal 3, c.size
+    end
+
+    should "add connection" do
+      c = Collection.new :connections => [ Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 1}) ]
+      assert_equal 1, c.size
+
+      c.add(Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 1 }))
+      assert_equal 2, c.size
+    end
+
+    should "remove connections" do
+      c = Collection.new :connections => [
+        Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 1 }),
+        Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 1 })
+      ]
+      assert_equal 2, c.size
+
+      c.remove([c.first])
+      assert_equal 1, c.size
+
+      c.remove(c)
+      assert_equal 0, c.size
+    end
+
+    should "remove connection" do
+      c = Collection.new :connections => [
+        Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 1 }),
+        Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 1 })
+      ]
+      assert_equal 2, c.size
+
+      c.remove(c.first)
+      assert_equal 1, c.size
+    end
+
     context "with the dead pool" do
       setup do
         @collection = Collection.new :connections => [ Connection.new(:host => 'foo'), Connection.new(:host => 'bar') ]
@@ -66,8 +108,8 @@ class Elasticsearch::Transport::Transport::Connections::CollectionTest < Test::U
       end
 
       should "resurrect dead connection with least failures when no alive is available" do
-        c1 = Connection.new(:host => 'foo').dead!.dead!
-        c2 = Connection.new(:host => 'bar').dead!
+        c1 = Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 123 }).dead!.dead!
+        c2 = Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 123 }).dead!
 
         @collection = Collection.new :connections => [ c1, c2 ]
 

data/test/unit/connection_test.rb

@@ -95,6 +95,15 @@ class Elasticsearch::Transport::Transport::Connections::ConnectionTest < Test::U
       assert ! c.dead?,      c.inspect
     end
 
+    should "implement the equality operator" do
+      c1 = Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 123 })
+      c2 = Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 123 })
+      c3 = Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 456 })
+
+      assert c1 == c2, "Connection #{c1} should be equal to #{c2}"
+      assert c2 != c3, "Connection #{c2} should NOT be equal to #{c3}"
+    end
+
   end
 
 end

data/test/unit/transport_base_test.rb

@@ -8,7 +8,9 @@ class Elasticsearch::Transport::Transport::BaseTest < Test::Unit::TestCase
 
   class DummyTransport
     include Elasticsearch::Transport::Transport::Base
-    def __build_connections; hosts; end
+    def __build_connection(host, options={}, block=nil)
+      Elasticsearch::Transport::Transport::Connections::Connection.new :host => host, :connection => Object.new
+    end
   end
 
   class DummyTransportPerformer < DummyTransport
@@ -24,9 +26,9 @@ class Elasticsearch::Transport::Transport::BaseTest < Test::Unit::TestCase
   end
 
   context "Transport::Base" do
-    should "raise exception when it doesn't implement __build_connections" do
+    should "raise exception when it doesn't implement __build_connection" do
       assert_raise NoMethodError do
-        EmptyTransport.new.__build_connections
+        EmptyTransport.new.__build_connection({ :host => 'foo'}, {})
       end
     end
 
@@ -488,6 +490,20 @@ class Elasticsearch::Transport::Transport::BaseTest < Test::Unit::TestCase
         @transport.reload_connections!
       end
     end
+
+    should "keep existing connections" do
+      @transport.__rebuild_connections :hosts => [ { :host => 'node1', :port => 1 } ], :options => { :http => {} }
+      assert_equal 1, @transport.connections.size
+
+      old_connection_id = @transport.connections.first.object_id
+
+      @transport.__rebuild_connections :hosts => [ { :host => 'node1', :port => 1 },
+                                                   { :host => 'node2', :port => 2 } ],
+                                       :options => { :http => {} }
+
+      assert_equal 2, @transport.connections.size
+      assert_equal old_connection_id, @transport.connections.first.object_id
+    end
   end
 
   context "rebuilding connections" do
@@ -497,13 +513,16 @@ class Elasticsearch::Transport::Transport::BaseTest < Test::Unit::TestCase
 
     should "close connections" do
       @transport.expects(:__close_connections)
-      @transport.__rebuild_connections :hosts => ['foo']
+      @transport.__rebuild_connections :hosts => [ { :scheme => 'http', :host => 'foo', :port => 1 } ], :options => { :http => {} }
     end
 
     should "should replace the connections" do
-      assert_equal [], @transport.connections
-      @transport.__rebuild_connections :hosts => ['foo', 'bar']
-      assert_equal ['foo', 'bar'], @transport.connections
+      assert_equal 0, @transport.connections.size
+
+      @transport.__rebuild_connections :hosts => [{ :scheme => 'http', :host => 'foo', :port => 1 }],
+                                       :options => { :http => {} }
+
+      assert_equal 1, @transport.connections.size
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-transport
 version: !ruby/object:Gem::Version
-  version: 1.0.16
+  version: 1.0.17
 platform: ruby
 authors:
 - Karel Minarik