elasticsearch 7.1.0 → 8.10.0

data/lib/elasticsearch/version.rb

@@ -6,7 +6,7 @@
 # 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
+#   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
@@ -16,5 +16,5 @@
 # under the License.
 
 module Elasticsearch
-  VERSION = "7.1.0"
+  VERSION = '8.10.0'.freeze
 end

data/lib/elasticsearch-ruby.rb

@@ -6,7 +6,7 @@
 # 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
+#   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

data/lib/elasticsearch.rb

@@ -6,7 +6,7 @@
 # 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
+#   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
@@ -15,15 +15,186 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require "elasticsearch/version"
-
-require 'elasticsearch/transport'
+require 'elasticsearch/version'
+require 'elastic/transport'
 require 'elasticsearch/api'
 
 module Elasticsearch
-  module Transport
-    class Client
-      include Elasticsearch::API
+  NOT_ELASTICSEARCH_WARNING = 'The client noticed that the server is not Elasticsearch and we do not support this unknown product.'.freeze
+  SECURITY_PRIVILEGES_VALIDATION_WARNING = 'The client is unable to verify that the server is Elasticsearch due to security privileges on the server side. Some functionality may not be compatible if the server is running an unsupported product.'.freeze
+  VALIDATION_WARNING = 'The client is unable to verify that the server is Elasticsearch. Some functionality may not be compatible if the server is running an unsupported product.'.freeze
+
+  # This is the stateful Elasticsearch::Client, using an instance of elastic-transport.
+  class Client
+    include Elasticsearch::API
+    # The default port to use if connecting using a Cloud ID.
+    # Updated from 9243 to 443 in client version 7.10.1
+    #
+    # @since 7.2.0
+    DEFAULT_CLOUD_PORT = 443
+
+    # Create a client connected to an Elasticsearch cluster.
+    #
+    # @param [Hash] arguments - initializer arguments
+    # @option arguments [String] :cloud_id - The Cloud ID to connect to Elastic Cloud
+    # @option arguments [String, Hash] :api_key Use API Key Authentication, either the base64 encoding of `id` and `api_key`
+    #                                           joined by a colon as a String, or a hash with the `id` and `api_key` values.
+    # @option arguments [String] :opaque_id_prefix set a prefix for X-Opaque-Id when initializing the client.
+    #                                              This will be prepended to the id you set before each request
+    #                                              if you're using X-Opaque-Id
+    # @option arguments [Hash] :headers Custom HTTP Request Headers
+    #
+    def initialize(arguments = {}, &block)
+      @verified = false
+      @warned = false
+      @opaque_id_prefix = arguments[:opaque_id_prefix] || nil
+      api_key(arguments) if arguments[:api_key]
+      setup_cloud(arguments) if arguments[:cloud_id]
+      set_user_agent!(arguments) unless sent_user_agent?(arguments)
+      @transport = Elastic::Transport::Client.new(arguments, &block)
+    end
+
+    def method_missing(name, *args, &block)
+      if methods.include?(name)
+        super
+      elsif name == :perform_request
+        # The signature for perform_request is:
+        # method, path, params, body, headers
+        if (opaque_id = args[2]&.delete(:opaque_id))
+          headers = args[4] || {}
+          opaque_id = @opaque_id_prefix ? "#{@opaque_id_prefix}#{opaque_id}" : opaque_id
+          args[4] = headers.merge('X-Opaque-Id' => opaque_id)
+        end
+        unless @verified
+          verify_elasticsearch(*args, &block)
+        else
+          @transport.perform_request(*args, &block)
+        end
+      else
+        @transport.send(name, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method_name, *args)
+      @transport.respond_to?(method_name) || super
+    end
+
+    private
+
+    def verify_elasticsearch(*args, &block)
+      begin
+        response = @transport.perform_request(*args, &block)
+      rescue Elastic::Transport::Transport::Errors::Unauthorized,
+             Elastic::Transport::Transport::Errors::Forbidden,
+             Elastic::Transport::Transport::Errors::RequestEntityTooLarge => e
+        warn(SECURITY_PRIVILEGES_VALIDATION_WARNING)
+        @verified = true
+        raise e
+      rescue Elastic::Transport::Transport::Error => e
+        unless @warned
+          warn(VALIDATION_WARNING)
+          @warned = true
+        end
+        raise e
+      rescue StandardError => e
+        warn(VALIDATION_WARNING)
+        raise e
+      end
+      raise Elasticsearch::UnsupportedProductError unless response.headers['x-elastic-product'] == 'Elasticsearch'
+      @verified = true
+      response
+    end
+
+    def setup_cloud_host(cloud_id, user, password, port)
+      name = cloud_id.split(':')[0]
+      cloud_url, elasticsearch_instance = Base64.decode64(cloud_id.gsub("#{name}:", '')).split('$')
+
+      if cloud_url.include?(':')
+        url, port = cloud_url.split(':')
+        host = "#{elasticsearch_instance}.#{url}"
+      else
+        host = "#{elasticsearch_instance}.#{cloud_url}"
+        port ||= DEFAULT_CLOUD_PORT
+      end
+      [{ scheme: 'https', user: user, password: password, host: host, port: port.to_i }]
+    end
+
+    def api_key(arguments)
+      api_key = if arguments[:api_key].is_a? Hash
+                  encode(arguments[:api_key])
+                else
+                  arguments[:api_key]
+                end
+      arguments.delete(:user)
+      arguments.delete(:password)
+      authorization = { 'Authorization' => "ApiKey #{api_key}" }
+      if (headers = arguments.dig(:transport_options, :headers))
+        headers.merge!(authorization)
+      else
+        arguments[:transport_options] ||= {}
+        arguments[:transport_options].merge!({ headers: authorization })
+      end
+    end
+
+    def setup_cloud(arguments)
+      arguments[:hosts] = setup_cloud_host(
+        arguments[:cloud_id],
+        arguments[:user],
+        arguments[:password],
+        arguments[:port]
+      )
+    end
+
+    # Encode credentials for the Authorization Header
+    # Credentials is the base64 encoding of id and api_key joined by a colon
+    # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-create-api-key.html
+    def encode(api_key)
+      Base64.strict_encode64([api_key[:id], api_key[:api_key]].join(':'))
+    end
+
+    def elasticsearch_validation_request
+      @transport.perform_request('GET', '/')
+    end
+
+    def sent_user_agent?(arguments)
+      return unless (headers = arguments&.[](:transport_options)&.[](:headers))
+      !!headers.keys.detect { |h| h =~ /user-?_?agent/ }
+    end
+
+    def set_user_agent!(arguments)
+      user_agent = [
+        "elasticsearch-ruby/#{Elasticsearch::VERSION}",
+        "elastic-transport-ruby/#{Elastic::Transport::VERSION}",
+        "RUBY_VERSION: #{RUBY_VERSION}"
+      ]
+      if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+        user_agent << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
+      end
+      arguments[:transport_options] ||= {}
+      arguments[:transport_options][:headers] ||= {}
+      arguments[:transport_options][:headers].merge!({ user_agent: user_agent.join('; ')})
     end
   end
+
+  # Error class for when we detect an unsupported version of Elasticsearch
+  class UnsupportedProductError < StandardError
+    def initialize(message = NOT_ELASTICSEARCH_WARNING)
+      super(message)
+    end
+  end
+end
+
+# Helper for the meta-header value for Cloud
+module Elastic
+  # If the version is X.X.X.pre/alpha/beta, use X.X.Xp for the meta-header:
+  def self.client_meta_version
+    regexp = /^([0-9]+\.[0-9]+\.[0-9]+)\.?([a-z0-9.-]+)?$/
+    match = Elasticsearch::VERSION.match(regexp)
+    return "#{match[1]}p" if match[2]
+
+    Elasticsearch::VERSION
+  end
+
+  # Constant for elastic-transport meta-header
+  ELASTICSEARCH_SERVICE_VERSION = [:es, client_meta_version].freeze
 end

data/spec/integration/characters_escaping_spec.rb

@@ -0,0 +1,94 @@
+# 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.
+ELASTICSEARCH_URL = ENV['TEST_ES_SERVER'] || "http://localhost:#{(ENV['PORT'] || 9200)}"
+raise URI::InvalidURIError unless ELASTICSEARCH_URL =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+
+require 'spec_helper'
+
+context 'Elasticsearch client' do
+  let(:client) do
+    Elasticsearch::Client.new(host: ELASTICSEARCH_URL, user: 'elastic', password: 'changeme')
+  end
+  let(:index) { 'tvs' }
+
+  after do
+    client.indices.delete(index: index)
+  end
+
+  context 'escaping spaces in ids' do
+    it 'escapes spaces for id when using index' do
+      response = client.index(index: index, id: 'a test 1', body: { name: 'A test 1' }, refresh: true)
+      expect(response.body['_id']).to eq 'a test 1'
+
+      response = client.search(index: index)
+      expect(response.body['hits']['hits'].first['_id']).to eq 'a test 1'
+
+      # Raises exception, _id is unrecognized
+      expect do
+        client.index(index: index, _id: 'a test 2', body: { name: 'A test 2' })
+      end.to raise_exception Elastic::Transport::Transport::Errors::BadRequest
+
+      # Raises exception, id is a query parameter
+      expect do
+        client.index(index: index, body: { name: 'A test 3', _id: 'a test 3' })
+      end.to raise_exception Elastic::Transport::Transport::Errors::BadRequest
+    end
+
+    it 'escapes spaces for id when using create' do
+      # Works with create
+      response = client.create(index: index, id: 'a test 4', body: { name: 'A test 4' })
+      expect(response.body['_id']).to eq 'a test 4'
+    end
+
+    it 'escapes spaces for id when using bulk' do
+      body = [
+        { create: { _index: index, _id: 'a test 5', data: { name: 'A test 5' } } }
+      ]
+      expect(client.bulk(body: body, refresh: true).status).to eq 200
+
+      response = client.search(index: index)
+      expect(
+        response.body['hits']['hits'].select { |a| a['_id'] == 'a test 5' }.size
+      ).to eq 1
+    end
+  end
+
+  context 'it doesnae escape plus signs in id' do
+    it 'escapes spaces for id when using index' do
+      response = client.index(index: index, id: 'a+test+1', body: { name: 'A test 1' })
+      expect(response.body['_id']).to eq 'a+test+1'
+    end
+
+    it 'escapes spaces for id when using create' do
+      # Works with create
+      response = client.create(index: index, id: 'a+test+2', body: { name: 'A test 2' })
+      expect(response.body['_id']).to eq 'a+test+2'
+    end
+
+    it 'escapes spaces for id when using bulk' do
+      body = [
+        { create: { _index: index, _id: 'a+test+3', data: { name: 'A test 3' } } }
+      ]
+      expect(client.bulk(body: body, refresh: true).status).to eq 200
+
+      response = client.search(index: index)
+      expect(
+        response.body['hits']['hits'].select { |a| a['_id'] == 'a+test+3' }.size
+      ).to eq 1
+    end
+  end
+end

data/spec/integration/client_integration_spec.rb

@@ -0,0 +1,63 @@
+# 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.
+ELASTICSEARCH_URL = ENV['TEST_ES_SERVER'] || "http://localhost:#{(ENV['PORT'] || 9200)}"
+raise URI::InvalidURIError unless ELASTICSEARCH_URL =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+
+require 'spec_helper'
+require 'logger'
+
+context 'Elasticsearch client' do
+  let(:logger) { Logger.new($stderr) }
+
+  let(:client) do
+    Elasticsearch::Client.new(
+      host: ELASTICSEARCH_URL,
+      logger: logger,
+      user: 'elastic',
+      password: 'changeme'
+    )
+  end
+
+  context 'Integrates with elasticsearch API' do
+    it 'should perform the API methods' do
+      expect do
+        # Index a document
+        client.index(index: 'test-index', id: '1', body: { title: 'Test' })
+
+        # Refresh the index
+        client.indices.refresh(index: 'test-index')
+
+        # Search
+        response = client.search(index: 'test-index', body: { query: { match: { title: 'test' } } })
+
+        expect(response['hits']['total']['value']).to eq 1
+        expect(response['hits']['hits'][0]['_source']['title']).to eq 'Test'
+
+        # Delete the index
+        client.indices.delete(index: 'test-index')
+      end.not_to raise_error
+    end
+  end
+
+  context 'Reports the right meta header' do
+    it 'Reports es service name and gem versio' do
+      headers = client.transport.connections.first.connection.headers
+      version = Class.new.extend(Elastic::Transport::MetaHeader).send(:client_meta_version, Elasticsearch::VERSION)
+      expect(headers['x-elastic-client-meta']).to match /^es=#{version}/
+    end
+  end
+end

data/spec/integration/helpers/bulk_helper_spec.rb

@@ -0,0 +1,211 @@
+# 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.
+ELASTICSEARCH_URL = ENV['TEST_ES_SERVER'] || "http://localhost:#{(ENV['PORT'] || 9200)}"
+raise URI::InvalidURIError unless ELASTICSEARCH_URL =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+
+require 'elasticsearch/helpers/bulk_helper'
+require 'spec_helper'
+require 'tempfile'
+
+context 'Elasticsearch client helpers' do
+  context 'Bulk helper' do
+    let(:client) do
+      Elasticsearch::Client.new(
+        host: ELASTICSEARCH_URL,
+        user: 'elastic',
+        password: 'changeme'
+      )
+    end
+    let(:index) { 'bulk_animals' }
+    let(:params) { { refresh: 'wait_for' } }
+    let(:bulk_helper) { Elasticsearch::Helpers::BulkHelper.new(client, index, params) }
+    let(:docs) do
+      [
+        { scientific_name: 'Lama guanicoe', name:'Guanaco' },
+        { scientific_name: 'Tayassu pecari', name:'White-lipped peccary' },
+        { scientific_name: 'Snycerus caffer', name:'Buffalo, african' },
+        { scientific_name: 'Coluber constrictor', name:'Snake, racer' },
+        { scientific_name: 'Thalasseus maximus', name:'Royal tern' },
+        { scientific_name: 'Centrocercus urophasianus', name:'Hen, sage' },
+        { scientific_name: 'Sitta canadensis', name:'Nuthatch, red-breasted' },
+        { scientific_name: 'Aegypius tracheliotus', name:'Vulture, lappet-faced' },
+        { scientific_name: 'Bucephala clangula', name:'Common goldeneye' },
+        { scientific_name: 'Felis pardalis', name:'Ocelot' }
+      ]
+    end
+
+    after do
+      client.indices.delete(index: index, ignore: 404)
+    end
+
+    it 'Ingests documents' do
+      response = bulk_helper.ingest(docs)
+      expect(response).to be_an_instance_of Elasticsearch::API::Response
+      expect(response.status).to eq(200)
+      expect(response['items'].map { |a| a['index']['status'] }.uniq.first).to eq 201
+    end
+
+    it 'Updates documents' do
+      docs = [
+        { scientific_name: 'Otocyon megalotos', name: 'Bat-eared fox' },
+        { scientific_name: 'Herpestes javanicus', name: 'Small Indian mongoose' }
+      ]
+      bulk_helper.ingest(docs)
+      # Get the ingested documents, add id and modify them to update them:
+      animals = client.search(index: index)['hits']['hits']
+      # Add id to each doc
+      docs = animals.map { |animal| animal['_source'].merge({'id' => animal['_id'] }) }
+      docs.map { |doc| doc['scientific_name'].upcase! }
+      response = bulk_helper.update(docs)
+      expect(response.status).to eq(200)
+      expect(response['items'].map { |i| i['update']['result'] }.uniq.first).to eq('updated')
+    end
+
+    it 'Deletes documents' do
+      response = bulk_helper.ingest(docs)
+      ids = response.body['items'].map { |a| a['index']['_id'] }
+      response = bulk_helper.delete(ids)
+      expect(response.status).to eq 200
+      expect(response['items'].map { |item| item['delete']['result'] }.uniq.first).to eq('deleted')
+      expect(client.count(index: index)['count']).to eq(0)
+    end
+
+    it 'Ingests documents and yields response and docs' do
+      slice = 2
+      response = bulk_helper.ingest(docs, {slice: slice}) do |response, docs|
+        expect(response).to be_an_instance_of Elasticsearch::API::Response
+        expect(docs.count).to eq slice
+      end
+    end
+
+    context 'JSON File helper' do
+      let(:file) { Tempfile.new('test-data.json') }
+      let(:json) do
+        json = <<~JSON
+        [
+          {
+            "character_name": "Anallese Lonie",
+           "species": "mouse",
+           "catchphrase": "Seamless regional definition",
+           "favorite_food": "pizza"
+          },
+          {
+            "character_name": "Janey Davidovsky",
+           "species": "cat",
+           "catchphrase": "Down-sized responsive pricing structure",
+           "favorite_food": "pizza"
+          },
+          {
+            "character_name": "Morse Mountford",
+           "species": "cat",
+           "catchphrase": "Ameliorated modular data-warehouse",
+           "favorite_food": "carrots"
+          },
+          {
+            "character_name": "Saundra Kauble",
+           "species": "dog",
+           "catchphrase": "Synchronised 24/7 support",
+           "favorite_food": "carrots"
+          },
+          {
+            "character_name": "Kain Viggars",
+           "species": "cat",
+           "catchphrase": "Open-architected asymmetric circuit",
+           "favorite_food": "carrots"
+          }
+        ]
+        JSON
+      end
+
+      before do
+        file.write(json)
+        file.rewind
+      end
+
+      after do
+        file.close
+        file.unlink
+      end
+
+      it 'Ingests a JSON file' do
+        response = bulk_helper.ingest_json(file)
+
+        expect(response).to be_an_instance_of Elasticsearch::API::Response
+        expect(response.status).to eq(200)
+      end
+
+      context 'with data not in root of JSON file' do
+        let(:json) do
+          json = <<~JSON
+          {
+            "field": "value",
+            "status": 200,
+            "data": {
+              "items": [
+                {
+                  "character_name": "Anallese Lonie",
+                  "species": "mouse",
+                  "catchphrase": "Seamless regional definition",
+                  "favorite_food": "pizza"
+                },
+                {
+                  "character_name": "Janey Davidovsky",
+                  "species": "cat",
+                  "catchphrase": "Down-sized responsive pricing structure",
+                  "favorite_food": "pizza"
+                },
+                {
+                  "character_name": "Morse Mountford",
+                  "species": "cat",
+                  "catchphrase": "Ameliorated modular data-warehouse",
+                  "favorite_food": "carrots"
+                },
+                {
+                  "character_name": "Saundra Kauble",
+                  "species": "dog",
+                  "catchphrase": "Synchronised 24/7 support",
+                  "favorite_food": "carrots"
+                },
+                {
+                  "character_name": "Kain Viggars",
+                  "species": "cat",
+                  "catchphrase": "Open-architected asymmetric circuit",
+                  "favorite_food": "carrots"
+                }
+              ]
+            }
+          }
+          JSON
+        end
+
+        it 'Ingests a JSON file passing keys as Array' do
+          response = bulk_helper.ingest_json(file, { keys: ['data', 'items'] })
+          expect(response).to be_an_instance_of Elasticsearch::API::Response
+          expect(response.status).to eq(200)
+          expect(response['items'].map { |a| a['index']['status'] }.uniq.first).to eq 201
+        end
+
+        it 'Ingests a JSON file passing keys as String' do
+          response = bulk_helper.ingest_json(file, { keys: 'data,items' })
+          expect(response).to be_an_instance_of Elasticsearch::API::Response
+          expect(response.status).to eq(200)
+          expect(response['items'].map { |a| a['index']['status'] }.uniq.first).to eq 201
+        end
+      end
+    end
+  end
+end