elasticsearch-transport 0.0.2

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

@@ -0,0 +1,20 @@
+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
+        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', '_cluster/nodes').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 = "0.0.2"
+  end
+end

data/test/integration/client_test.rb

@@ -0,0 +1,117 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+  startup do
+    Elasticsearch::TestCluster.start if ENV['SERVER'] and not Elasticsearch::TestCluster.running?
+  end
+
+  context "Elasticsearch client" do
+    setup do
+      system "curl -X DELETE http://localhost:9250/_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:9250'
+    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'}
+      response = @client.perform_request 'GET', 'myindex/mydoc/1?routing=XYZ'
+      assert_equal true, response.body['exists']
+      assert_equal 'bar', response.body['_source']['foo']
+      assert_raise Elasticsearch::Transport::Transport::Errors::NotFound do
+        response = @client.perform_request 'GET', 'myindex/mydoc/1?routing=ABC'
+        assert_nil response.body['_source']
+        assert_equal false, response.body['exists']
+      end
+    end
+
+    context "with round robin selector" do
+      setup do
+        @client = Elasticsearch::Client.new \
+                    hosts: %w| localhost:9250 localhost:9251 |,
+                    logger: @logger
+      end
+
+      should "rotate nodes" do
+        # Hit node 1
+        response = @client.perform_request 'GET', '_cluster/nodes/_local'
+        assert_equal 'node-1', response.body['nodes'].to_a[0][1]['name']
+
+        # Hit node 2
+        response = @client.perform_request 'GET', '_cluster/nodes/_local'
+        assert_equal 'node-2', response.body['nodes'].to_a[0][1]['name']
+
+        # Hit node 1
+        response = @client.perform_request 'GET', '_cluster/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
+        @client = Elasticsearch::Client.new \
+                    hosts: %w| localhost:9250 foobar1 |,
+                    logger: @logger,
+                    retry_on_failure: true
+      end
+
+      should "retry the request with next server" do
+        assert_nothing_raised do
+          5.times { @client.perform_request 'GET', '_cluster/nodes/_local' }
+        end
+      end
+
+      should "raise exception when it cannot get any healthy server" do
+        @client = Elasticsearch::Client.new \
+                  hosts: %w| localhost:9250 foobar1 foobar2 foobar3 |,
+                  logger: @logger,
+                  retry_on_failure: 1
+
+        assert_nothing_raised do
+          # First hit is OK
+          @client.perform_request 'GET', '_cluster/nodes/_local'
+        end
+
+        assert_raise Faraday::Error::ConnectionFailed do
+          # Second hit fails
+          @client.perform_request 'GET', '_cluster/nodes/_local'
+        end
+      end
+    end
+
+    context "with a sick node and reloading on failure" do
+      setup do
+        @client = Elasticsearch::Client.new \
+                  hosts: %w| localhost:9250 foobar1 foobar2 |,
+                  logger: @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', '_cluster/nodes/_local' }
+        end
+        assert_equal 2, @client.transport.connections.size
+      end
+    end
+
+  end
+end

data/test/integration/transport_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+  startup do
+    Elasticsearch::TestCluster.start if ENV['SERVER'] and not Elasticsearch::TestCluster.running?
+  end
+
+  context "Transport" do
+    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 => '9250' } ] do |f|
+          f.response :logger
+          f.adapter  :typhoeus
+        end
+
+      client = Elasticsearch::Transport::Client.new transport: transport
+      client.perform_request 'GET', ''
+    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 => '9250' } ] do |curl|
+          curl.verbose = true
+        end
+
+      client = Elasticsearch::Transport::Client.new transport: transport
+      client.perform_request 'GET', ''
+    end
+  end
+
+end

data/test/profile/client_benchmark_test.rb

@@ -0,0 +1,107 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::ClientProfilingTest < Elasticsearch::Test::ProfilingTest
+  startup do
+    Elasticsearch::TestCluster.start if ENV['SERVER'] and not Elasticsearch::TestCluster.running?
+  end
+
+  context "Elasticsearch client benchmark" do
+    setup do
+      client = Elasticsearch::Client.new host: 'localhost:9250'
+      client.perform_request 'DELETE', '/ruby_test_benchmark/' rescue nil
+      client.perform_request 'POST',   '/ruby_test_benchmark/', {index: {number_of_shards: 1, number_of_replicas: 0}}
+      100.times do client.perform_request 'POST',   '/ruby_test_benchmark_search/test/', {}, {foo: 'bar'}; end
+      client.perform_request 'POST',   '/ruby_test_benchmark_search/_refresh'
+    end
+    teardown do
+      client = Elasticsearch::Client.new host: 'localhost:9250'
+      client.perform_request 'DELETE', '/ruby_test_benchmark/'
+      client.perform_request 'DELETE', '/ruby_test_benchmark_search/'
+    end
+
+    context "with a single-node cluster" do
+      setup do
+        @client = Elasticsearch::Client.new hosts: 'localhost:9250'
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document" do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+
+    context "with a two-node cluster" do
+      setup do
+        @client = Elasticsearch::Client.new hosts: ['localhost:9250', 'localhost:9251']
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document"do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+
+    context "with a single-node cluster and the Curb client" do
+      setup do
+        require 'curb'
+        require 'elasticsearch/transport/transport/http/curb'
+        @client = Elasticsearch::Client.new host: 'localhost:9250',
+                                            transport_class: Elasticsearch::Transport::Transport::HTTP::Curb
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document" do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+
+    context "with a single-node cluster and the Typhoeus client" do
+      setup do
+        require 'typhoeus'
+        require 'typhoeus/adapters/faraday'
+
+        transport = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
+          :hosts => [ { :host => 'localhost', :port => '9250' } ] do |f|
+            f.adapter  :typhoeus
+          end
+
+        @client = Elasticsearch::Client.new transport: transport
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document" do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+
+  end
+
+end

data/test/test_extensions.rb

@@ -0,0 +1,139 @@
+require 'benchmark'
+require 'ruby-prof'
+require 'ansi/code'
+require 'ansi/terminal'
+
+module Elasticsearch
+  module Test
+
+    # Startup/shutdown support for test suites
+    #
+    # Example:
+    #
+    #     class MyTest < Test::Unit::TestCase
+    #       extend IntegrationTestStartupShutdown
+    #
+    #       startup  { puts "Suite starting up..." }
+    #       shutdown { puts "Suite shutting down..." }
+    #     end
+    #
+    # *** IMPORTANT NOTE: **********************************************************
+    #
+    # You have to register the handler for shutdown before requiring 'test/unit':
+    #
+    #     # File: test_helper.rb
+    #     at_exit { MyTest.__run_at_exit_hooks }
+    #     require 'test/unit'
+    #
+    # The API follows Test::Unit 2.0
+    # <https://github.com/test-unit/test-unit/blob/master/lib/test/unit/testcase.rb>
+    #
+    module IntegrationTestStartupShutdown
+      @@started           = false
+      @@shutdown_blocks ||= []
+
+      def startup &block
+        return if started?
+        @@started = true
+        yield block if block_given?
+      end
+
+      def shutdown &block
+        @@shutdown_blocks << block if block_given?
+      end
+
+      def started?
+        !! @@started
+      end
+
+      def __run_at_exit_hooks
+        return unless started?
+        STDERR.puts ANSI.faint("Running at_exit hooks...")
+        puts ANSI.faint('-'*80)
+        @@shutdown_blocks.each { |b| b.call }
+        puts ANSI.faint('-'*80)
+      end
+    end
+
+    # Profiling support for tests with [ruby-prof](https://github.com/ruby-prof/ruby-prof)
+    #
+    # Example:
+    #
+    #     measure "divide numbers", count: 10_000 do
+    #      assert_nothing_raised { 1/2 }
+    #     end
+    #
+    # Will print out something like this along your test output:
+    #
+    #     ---------------------------------------------------------------------
+    #     Context: My benchmark should divide numbers (10000x)
+    #     mean: 0.01ms | avg: 0.01ms | max: 6.19ms
+    #     ---------------------------------------------------------------------
+    #     ...
+    #     Total: 0.313283
+    #
+    #      %self      total      self      wait     child     calls  name
+    #      25.38      0.313     0.079     0.000     0.234        1   <Object::MyTets>#__bind_1368638677_723101
+    #      14.42      0.118     0.045     0.000     0.073    20000   <Class::Time>#now
+    #      7.57       0.088     0.033     0.000     0.055    10000   Time#-
+    #      ...
+    #
+    #     PASS (0:00:00.322) test: My benchmark should divide numbers (10000x).
+    #
+    #
+    module ProfilingTestSupport
+
+      # Profiles the passed block of code.
+      #
+      #     measure "divide numbers", count: 10_000 do
+      #      assert_nothing_raised { 1/2 }
+      #     end
+      #
+      # @todo Try to make progress bar not interfere with tests
+      #
+      def measure(name, options={}, &block)
+        # require 'pry'; binding.pry
+        ___          = '-'*ANSI::Terminal.terminal_width
+        test_name    = self.name.split('::').last
+        context_name = self.context(nil) {}.first.parent.name
+        count        = Integer(ENV['COUNT'] || options[:count] || 1_000)
+        ticks        = []
+        # progress   = ANSI::Progressbar.new("#{name} (#{count}x)", count)
+
+        should "#{name} (#{count}x)" do
+          RubyProf.start
+
+          count.times do
+            ticks << Benchmark.realtime { self.instance_eval(&block) }
+            # RubyProf.pause
+            # progress.inc
+            # RubyProf.resume
+          end
+
+          result = RubyProf.stop
+          # progress.finish
+
+          total = result.threads.reduce(0) { |total,info| total += info.total_time; total }
+          mean  = (ticks.sort[(ticks.size/2).round-1])*1000
+          avg   = (ticks.inject {|sum,el| sum += el; sum}.to_f/ticks.size)*1000
+          max   = ticks.max*1000
+
+
+          result.eliminate_methods!([/Integer#times|Benchmark.realtime|ANSI::Code#.*|ANSI::ProgressBar#.*/])
+          printer = RubyProf::FlatPrinter.new(result)
+          # printer = RubyProf::GraphPrinter.new(result)
+
+          puts "\n",
+               ___,
+               'Context: ' + ANSI.bold(context_name) + ' should ' + ANSI.bold(name) + " (#{count}x)",
+               "mean: #{sprintf('%.2f', mean)}ms | " +
+               "avg: #{sprintf('%.2f',  avg)}ms | " +
+               "max: #{sprintf('%.2f',  max)}ms",
+               ___
+          printer.print(STDOUT, {}) unless ENV['QUIET'] || options[:quiet]
+        end
+      end
+    end
+
+  end
+end