elasticsearch-transport-sinneduy 1.0.12

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

@@ -0,0 +1,124 @@
+require 'manticore'
+
+module Elasticsearch
+  module Transport
+    module Transport
+      module HTTP
+        # Alternative HTTP transport implementation for JRuby,
+        # using the [_Manticore_](https://github.com/cheald/manticore) client,
+        #
+        # @example HTTP
+        #
+        #     require 'elasticsearch/transport/transport/http/manticore'
+        #
+        #     client = Elasticsearch::Client.new transport_class: Elasticsearch::Transport::Transport::HTTP::Manticore
+        #
+        #     client.transport.connections.first.connection
+        #     => #<Manticore::Client:0x56bf7ca6 ...>
+        #
+        #     client.info['status']
+        #     => 200
+        #
+        #  @example HTTPS (All SSL settings are optional,
+        #                  see http://www.rubydoc.info/gems/manticore/Manticore/Client:initialize)
+        #
+        #     require 'elasticsearch/transport/transport/http/manticore'
+        #
+        #     client = Elasticsearch::Client.new \
+        #       url: 'https://elasticsearch.example.com',
+        #       transport_class: Elasticsearch::Transport::Transport::HTTP::Manticore,
+        #       ssl: {
+        #         truststore: '/tmp/truststore.jks',
+        #         truststore_password: 'password',
+        #         keystore: '/tmp/keystore.jks',
+        #         keystore_password: 'secret',
+        #       }
+        #
+        #     client.transport.connections.first.connection
+        #     => #<Manticore::Client:0xdeadbeef ...>
+        #
+        #     client.info['status']
+        #     => 200
+        #
+        # @see Transport::Base
+        #
+        class Manticore
+          include Base
+
+          # Performs the request by invoking {Transport::Base#perform_request} with a block.
+          #
+          # @return [Response]
+          # @see    Transport::Base#perform_request
+          #
+          def perform_request(method, path, params={}, body=nil)
+            super do |connection, url|
+              params[:body] = __convert_to_json(body) if body
+              params = params.merge @request_options
+              case method
+              when "GET"
+                resp = connection.connection.get(url, params)
+              when "HEAD"
+                resp = connection.connection.head(url, params)
+              when "PUT"
+                resp = connection.connection.put(url, params)
+              when "POST"
+                resp = connection.connection.post(url, params)
+              when "DELETE"
+                resp = connection.connection.delete(url, params)
+              else
+                raise ArgumentError.new "Method #{method} not supported"
+              end
+              Response.new resp.code, resp.read_body, resp.headers
+            end
+          end
+
+          # Builds and returns a collection of connections.
+          # Each connection is a Manticore::Client
+          #
+          # @return [Connections::Collection]
+          #
+          def __build_connections
+            @request_options = {}
+
+            if options.key?(:headers)
+              @request_options[:headers] = options[:headers]
+            end
+
+            client_options = options[:transport_options] || {}
+            client_options[:ssl] = options[:ssl] || {}
+
+            Connections::Collection.new \
+              :connections => hosts.map { |host|
+                host[:protocol]   = host[:scheme] || DEFAULT_PROTOCOL
+                host[:port]     ||= DEFAULT_PORT
+
+                host.delete(:user)     # auth is not supported here.
+                host.delete(:password) # use the headers
+
+                url               = __full_url(host)
+
+                Connections::Connection.new \
+                  :host => host,
+                  :connection => ::Manticore::Client.new(client_options)
+              },
+              :selector_class => options[:selector_class],
+              :selector => options[:selector]
+          end
+
+          # Returns an array of implementation specific connection errors.
+          #
+          # @return [Array]
+          #
+          def host_unreachable_exceptions
+            [
+              ::Manticore::Timeout,
+              ::Manticore::SocketException,
+              ::Manticore::ClientProtocolException,
+              ::Manticore::ResolutionFailure
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/transport/transport/response.rb

@@ -0,0 +1,21 @@
+module Elasticsearch
+  module Transport
+    module Transport
+
+      # Wraps the response from Elasticsearch.
+      #
+      class Response
+        attr_reader :status, :body, :headers
+
+        # @param status  [Integer] Response status code
+        # @param body    [String]  Response body
+        # @param headers [Hash]    Response headers
+        def initialize(status, body, headers={})
+          @status, @body, @headers = status, body, headers
+          @body = body.force_encoding('UTF-8') if body.respond_to?(:force_encoding)
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/transport/transport/serializer/multi_json.rb

@@ -0,0 +1,36 @@
+module Elasticsearch
+  module Transport
+    module Transport
+      module Serializer
+
+        # An abstract class for implementing serializer implementations
+        #
+        module Base
+          # @param transport [Object] The instance of transport which uses this serializer
+          #
+          def initialize(transport=nil)
+            @transport = transport
+          end
+        end
+
+        # A default JSON serializer (using [MultiJSON](http://rubygems.org/gems/multi_json))
+        #
+        class MultiJson
+          include Base
+
+          # De-serialize a Hash from JSON string
+          #
+          def load(string, options={})
+            ::MultiJson.load(string, options)
+          end
+
+          # Serialize a Hash to JSON string
+          #
+          def dump(object, options={})
+            ::MultiJson.dump(object, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/transport/transport/sniffer.rb

@@ -0,0 +1,46 @@
+module Elasticsearch
+  module Transport
+    module Transport
+
+      # Handles node discovery ("sniffing").
+      #
+      class Sniffer
+        RE_URL  = /\/([^:]*):([0-9]+)\]/ # Use named groups on Ruby 1.9: /\/(?<host>[^:]*):(?<port>[0-9]+)\]/
+
+        attr_reader   :transport
+        attr_accessor :timeout
+
+        # @param transport [Object] A transport instance.
+        #
+        def initialize(transport)
+          @transport = transport
+          @timeout   = transport.options[:sniffer_timeout] || 1
+        end
+
+        # Retrieves the node list from the Elasticsearch's
+        # [_Nodes Info API_](http://www.elasticsearch.org/guide/reference/api/admin-cluster-nodes-info/)
+        # and returns a normalized Array of information suitable for passing to transport.
+        #
+        # Shuffles the collection before returning it when the `randomize_hosts` option is set for transport.
+        #
+        # @return [Array<Hash>]
+        # @raise  [SnifferTimeoutError]
+        #
+        def hosts
+          Timeout::timeout(timeout, SnifferTimeoutError) do
+            nodes = transport.perform_request('GET', '_nodes/http').body
+            hosts = nodes['nodes'].map do |id,info|
+              if matches = info["#{transport.protocol}_address"].to_s.match(RE_URL)
+                # TODO: Implement lightweight "indifferent access" here
+                info.merge :host => matches[1], :port => matches[2], :id => id
+              end
+            end.compact
+
+            hosts.shuffle! if transport.options[:randomize_hosts]
+            hosts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/transport/version.rb

@@ -0,0 +1,5 @@
+module Elasticsearch
+  module Transport
+    VERSION = "1.0.12"
+  end
+end

data/test/integration/client_test.rb

@@ -0,0 +1,144 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+  startup do
+    Elasticsearch::Extensions::Test::Cluster.start(nodes: 2) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
+  end
+
+  context "Elasticsearch client" do
+    teardown do
+      begin; Object.send(:remove_const, :Typhoeus); rescue NameError; end
+      begin; Object.send(:remove_const, :Patron); rescue NameError; end
+    end
+
+    setup do
+      @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+      system "curl -X DELETE http://localhost:#{@port}/_all > /dev/null 2>&1"
+
+      @logger =  Logger.new(STDERR)
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        color = case severity
+          when /INFO/ then :green
+          when /ERROR|WARN|FATAL/ then :red
+          when /DEBUG/ then :cyan
+          else :white
+        end
+        ANSI.ansi(severity[0] + ' ', color, :faint) + ANSI.ansi(msg, :white, :faint) + "\n"
+      end
+
+      @client = Elasticsearch::Client.new host: "localhost:#{@port}"
+    end
+
+    should "connect to the cluster" do
+      assert_nothing_raised do
+        response = @client.perform_request 'GET', '_cluster/health'
+        assert_equal 2, response.body['number_of_nodes']
+      end
+    end
+
+    should "handle paths and URL parameters" do
+      @client.perform_request 'PUT', 'myindex/mydoc/1', {routing: 'XYZ'}, {foo: 'bar'}
+      @client.perform_request 'GET', '_cluster/health?wait_for_status=green', {}
+
+      response = @client.perform_request 'GET', 'myindex/mydoc/1?routing=XYZ'
+      assert_equal 200, response.status
+      assert_equal 'bar', response.body['_source']['foo']
+
+      assert_raise Elasticsearch::Transport::Transport::Errors::NotFound do
+        @client.perform_request 'GET', 'myindex/mydoc/1?routing=ABC'
+      end
+    end
+
+    should "pass options to the transport" do
+      @client = Elasticsearch::Client.new \
+        host: "localhost:#{@port}",
+        logger: (ENV['QUIET'] ? nil : @logger),
+        transport_options: { headers: { content_type: 'application/yaml' } }
+
+      response = @client.perform_request 'GET', '_cluster/health'
+      assert_match /---\ncluster_name:/, response.body.to_s
+    end
+
+    context "with round robin selector" do
+      setup do
+        @client = Elasticsearch::Client.new \
+                    hosts:  ["localhost:#{@port}", "localhost:#{@port+1}" ],
+                    logger: (ENV['QUIET'] ? nil : @logger)
+      end
+
+      should "rotate nodes" do
+        # Hit node 1
+        response = @client.perform_request 'GET', '_nodes/_local'
+        assert_equal 'node-1', response.body['nodes'].to_a[0][1]['name']
+
+        # Hit node 2
+        response = @client.perform_request 'GET', '_nodes/_local'
+        assert_equal 'node-2', response.body['nodes'].to_a[0][1]['name']
+
+        # Hit node 1
+        response = @client.perform_request 'GET', '_nodes/_local'
+        assert_equal 'node-1', response.body['nodes'].to_a[0][1]['name']
+      end
+    end
+
+    context "with a sick node and retry on failure" do
+      setup do
+        @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+        @client = Elasticsearch::Client.new \
+                    hosts: ["localhost:#{@port}", "foobar1"],
+                    logger: (ENV['QUIET'] ? nil : @logger),
+                    retry_on_failure: true
+      end
+
+      should "retry the request with next server" do
+        assert_nothing_raised do
+          5.times { @client.perform_request 'GET', '_nodes/_local' }
+        end
+      end
+
+      should "raise exception when it cannot get any healthy server" do
+        @client = Elasticsearch::Client.new \
+                  hosts: ["localhost:#{@port}", "foobar1", "foobar2", "foobar3"],
+                  logger: (ENV['QUIET'] ? nil : @logger),
+                  retry_on_failure: 1
+
+        assert_nothing_raised do
+          # First hit is OK
+          @client.perform_request 'GET', '_nodes/_local'
+        end
+
+        assert_raise Faraday::Error::ConnectionFailed do
+          # Second hit fails
+          @client.perform_request 'GET', '_nodes/_local'
+        end
+      end
+    end
+
+    context "with a sick node and reloading on failure" do
+      setup do
+        @client = Elasticsearch::Client.new \
+                  hosts: ["localhost:#{@port}", "foobar1", "foobar2"],
+                  logger: (ENV['QUIET'] ? nil : @logger),
+                  reload_on_failure: true
+      end
+
+      should "reload the connections" do
+        assert_equal 3, @client.transport.connections.size
+        assert_nothing_raised do
+          5.times { @client.perform_request 'GET', '_nodes/_local' }
+        end
+        assert_equal 2, @client.transport.connections.size
+      end
+    end
+
+    context "with Faraday adapters" do
+      should "automatically use the Patron client when loaded" do
+        require 'patron'
+        client = Elasticsearch::Transport::Client.new host: "localhost:#{@port}"
+
+        response = @client.perform_request 'GET', '_cluster/health'
+        assert_equal 200, response.status
+      end unless JRUBY
+    end
+  end
+end

data/test/integration/transport_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+  startup do
+    Elasticsearch::Extensions::Test::Cluster.start(nodes: 2) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
+  end
+
+  context "Transport" do
+    setup do
+      @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+      begin; Object.send(:remove_const, :Patron);   rescue NameError; end
+    end
+
+    should "allow to customize the Faraday adapter" do
+      require 'typhoeus'
+      require 'typhoeus/adapters/faraday'
+
+      transport = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
+        :hosts => [ { :host => 'localhost', :port => @port } ] do |f|
+          f.response :logger
+          f.adapter  :typhoeus
+        end
+
+      client = Elasticsearch::Transport::Client.new transport: transport
+      client.perform_request 'GET', ''
+    end
+
+    should "allow to define connection parameters and pass them" do
+      transport = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
+                    :hosts => [ { :host => 'localhost', :port => @port } ],
+                    :options => { :transport_options => {
+                                    :params => { :format => 'yaml' }
+                                  }
+                                }
+
+      client = Elasticsearch::Transport::Client.new transport: transport
+      response = client.perform_request 'GET', ''
+
+      assert response.body.start_with?("---\n"), "Response body should be YAML: #{response.body.inspect}"
+    end
+
+    should "use the Curb client" do
+      require 'curb'
+      require 'elasticsearch/transport/transport/http/curb'
+
+      transport = Elasticsearch::Transport::Transport::HTTP::Curb.new \
+        :hosts => [ { :host => 'localhost', :port => @port } ] do |curl|
+          curl.verbose = true
+        end
+
+      client = Elasticsearch::Transport::Client.new transport: transport
+      client.perform_request 'GET', ''
+    end unless JRUBY
+
+    should "deserialize JSON responses in the Curb client" do
+      require 'curb'
+      require 'elasticsearch/transport/transport/http/curb'
+
+      transport = Elasticsearch::Transport::Transport::HTTP::Curb.new \
+        :hosts => [ { :host => 'localhost', :port => @port } ] do |curl|
+          curl.verbose = true
+        end
+
+      client = Elasticsearch::Transport::Client.new transport: transport
+      response = client.perform_request 'GET', ''
+
+      assert_respond_to(response.body, :to_hash)
+      assert_not_nil response.body['name']
+      assert_equal 'application/json', response.headers['content-type']
+    end unless JRUBY
+  end
+
+end