elastic-transport 8.0.0.pre1

data/lib/elastic/transport/transport/response.rb

@@ -0,0 +1,36 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Elastic
+  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/elastic/transport/transport/serializer/multi_json.rb

@@ -0,0 +1,52 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Elastic
+  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/elastic/transport/transport/sniffer.rb

@@ -0,0 +1,101 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Elastic
+  module Transport
+    module Transport
+      # Handles node discovery ("sniffing")
+      #
+      class Sniffer
+        PROTOCOL = 'http'
+
+        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_](https://www.elastic.co/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 = perform_sniff_request.body
+
+            hosts = nodes['nodes'].map do |id, info|
+              next unless info[PROTOCOL]
+              host, port = parse_publish_address(info[PROTOCOL]['publish_address'])
+
+              {
+                id: id,
+                name: info['name'],
+                version: info['version'],
+                host: host,
+                port: port,
+                roles: info['roles'],
+                attributes: info['attributes']
+              }
+            end.compact
+
+            hosts.shuffle! if transport.options[:randomize_hosts]
+            hosts
+          end
+        end
+
+        private
+
+        def perform_sniff_request
+          transport.perform_request(
+            'GET', '_nodes/http', {}, nil, nil,
+            reload_on_failure: false
+          )
+        end
+
+        def parse_publish_address(publish_address)
+          # publish_address is in the format hostname/ip:port
+          if publish_address =~ /\//
+            parts = publish_address.partition('/')
+            [ parts[0], parse_address_port(parts[2])[1] ]
+          else
+            parse_address_port(publish_address)
+          end
+        end
+
+        def parse_address_port(publish_address)
+          # address is ipv6
+          if publish_address =~ /[\[\]]/
+            if parts = publish_address.match(/\A\[(.+)\](?::(\d+))?\z/)
+              [ parts[1], parts[2] ]
+            end
+          else
+            publish_address.split(':')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elastic/transport/version.rb

@@ -0,0 +1,22 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Elastic
+  module Transport
+    VERSION = '8.0.0.pre1'.freeze
+  end
+end

data/lib/elastic/transport.rb

@@ -0,0 +1,37 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'faraday'
+require 'multi_json'
+require 'time'
+require 'timeout'
+require 'uri'
+
+require 'elastic/transport/transport/loggable'
+require 'elastic/transport/transport/serializer/multi_json'
+require 'elastic/transport/transport/sniffer'
+require 'elastic/transport/transport/response'
+require 'elastic/transport/transport/errors'
+require 'elastic/transport/transport/base'
+require 'elastic/transport/transport/connections/selector'
+require 'elastic/transport/transport/connections/connection'
+require 'elastic/transport/transport/connections/collection'
+require 'elastic/transport/transport/http/faraday'
+require 'elastic/transport/client'
+require 'elastic/transport/redacted'
+
+require 'elastic/transport/version'

data/lib/elastic-transport.rb

@@ -0,0 +1,18 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'elastic/transport'

data/spec/elasticsearch/connections/collection_spec.rb

@@ -0,0 +1,266 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'spec_helper'
+
+describe Elastic::Transport::Transport::Connections::Collection do
+  describe '#initialize' do
+    let(:collection) do
+      described_class.new
+    end
+
+    it 'has an empty list of connections as a default' do
+      expect(collection.connections).to be_empty
+    end
+
+    it 'has a default selector class' do
+      expect(collection.selector).not_to be_nil
+    end
+
+    context 'when a selector class is specified' do
+      let(:collection) do
+        described_class.new(selector_class: Elastic::Transport::Transport::Connections::Selector::Random)
+      end
+
+      it 'sets the selector' do
+        expect(collection.selector).to be_a(Elastic::Transport::Transport::Connections::Selector::Random)
+      end
+    end
+  end
+
+  describe '#get_connection' do
+    let(:collection) do
+      described_class.new(selector_class: Elastic::Transport::Transport::Connections::Selector::Random)
+    end
+
+    before do
+      expect(collection.selector).to receive(:select).and_return('OK')
+    end
+
+    it 'uses the selector to select a connection' do
+      expect(collection.get_connection).to eq('OK')
+    end
+  end
+
+  describe '#hosts' do
+    let(:collection) do
+      described_class.new(
+        connections: [
+          double('connection', host: 'A'),
+          double('connection', host: 'B')
+        ]
+      )
+    end
+
+    it 'returns a list of hosts' do
+      expect(collection.hosts).to eq([ 'A', 'B'])
+    end
+  end
+
+  describe 'enumerable' do
+    let(:collection) do
+      described_class.new(
+        connections: [
+          double('connection', host: 'A', dead?: false),
+          double('connection', host: 'B', dead?: false)
+        ]
+      )
+    end
+
+    describe '#map' do
+      it 'responds to the method' do
+        expect(collection.map { |c| c.host.downcase }).to eq(['a', 'b'])
+      end
+    end
+
+    describe '#[]' do
+      it 'responds to the method' do
+        expect(collection[0].host).to eq('A')
+        expect(collection[1].host).to eq('B')
+      end
+    end
+
+    describe '#size' do
+      it 'responds to the method' do
+        expect(collection.size).to eq(2)
+      end
+    end
+
+    context 'when a connection is marked as dead' do
+      let(:collection) do
+        described_class.new(
+          connections: [
+            double('connection', host: 'A', dead?: true),
+            double('connection', host: 'B', dead?: false)
+          ]
+        )
+      end
+
+      it 'does not enumerate the dead connections' do
+        expect(collection.size).to eq(1)
+        expect(collection.collect { |c| c.host }).to eq(['B'])
+      end
+
+      context '#alive' do
+        it 'enumerates the alive connections' do
+          expect(collection.alive.collect { |c| c.host }).to eq(['B'])
+        end
+      end
+
+      context '#dead' do
+        it 'enumerates the alive connections' do
+          expect(collection.dead.collect { |c| c.host }).to eq(['A'])
+        end
+      end
+    end
+  end
+
+  describe '#add' do
+
+    let(:collection) do
+      described_class.new(
+        connections: [
+          double('connection', host: 'A', dead?: false),
+          double('connection', host: 'B', dead?: false)
+        ]
+      )
+    end
+
+    context 'when an array is provided' do
+      before do
+        collection.add([double('connection', host: 'C', dead?: false),
+                        double('connection', host: 'D', dead?: false)])
+      end
+
+      it 'adds the connections' do
+        expect(collection.size).to eq(4)
+      end
+    end
+
+    context 'when an element is provided' do
+      before do
+        collection.add(double('connection', host: 'C', dead?: false))
+      end
+
+      it 'adds the connection' do
+        expect(collection.size).to eq(3)
+      end
+    end
+  end
+
+  describe '#remove' do
+    let(:connections) do
+      [
+        double('connection', host: 'A', dead?: false),
+        double('connection', host: 'B', dead?: false)
+      ]
+    end
+
+    let(:collection) do
+      described_class.new(connections: connections)
+    end
+
+    context 'when an array is provided' do
+      before do
+        collection.remove(connections)
+      end
+
+      it 'removes the connections' do
+        expect(collection.size).to eq(0)
+      end
+    end
+
+    context 'when an element is provided' do
+      let(:connections) do
+        [
+          double('connection', host: 'A', dead?: false),
+          double('connection', host: 'B', dead?: false)
+        ]
+      end
+
+      before do
+        collection.remove(connections.first)
+      end
+
+      it 'removes the connection' do
+        expect(collection.size).to eq(1)
+      end
+    end
+  end
+
+  describe '#get_connection' do
+    context 'when all connections are dead' do
+      let(:connection_a) do
+        Elastic::Transport::Transport::Connections::Connection.new(host: { host: 'A' })
+      end
+
+      let(:connection_b) do
+        Elastic::Transport::Transport::Connections::Connection.new(host: { host: 'B' })
+      end
+
+      let(:collection) do
+        described_class.new(connections: [connection_a, connection_b])
+      end
+
+      before do
+        connection_a.dead!.dead!
+        connection_b.dead!
+      end
+
+      it 'returns the connection with the least failures' do
+        expect(collection.get_connection.host[:host]).to eq('B')
+      end
+    end
+
+    context 'when multiple threads are used' do
+      let(:connections) do
+        20.times.collect do |i|
+          Elastic::Transport::Transport::Connections::Connection.new(host: { host: i })
+        end
+      end
+
+      let(:collection) do
+        described_class.new(connections: connections)
+      end
+
+      it 'allows threads to select connections in parallel' do
+        expect(10.times.collect do
+                 threads = []
+                 20.times do
+                   threads << Thread.new do
+                     collection.get_connection
+                   end
+                 end
+                 threads.map { |t| t.join }
+                 collection.get_connection.host[:host]
+               end).to eq((0..9).to_a)
+      end
+
+      it 'always returns a connection' do
+        threads = 20.times.map do
+          Thread.new do
+            20.times.map do
+              collection.get_connection.dead!
+            end
+          end
+        end
+
+        expect(threads.flat_map(&:value).size).to eq(400)
+      end
+    end
+  end
+end