opensearch-ruby 2.0.3 → 3.4.0

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

@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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 OpenSearch
+  module Transport
+    module Transport
+      module Connections
+        # Wraps the connection information and logic.
+        #
+        # The Connection instance wraps the host information (hostname, port, attributes, etc),
+        # as well as the "session" (a transport client object, such as a {HTTP::Faraday} instance).
+        #
+        # It provides methods to construct and properly encode the URLs and paths for passing them
+        # to the transport client object.
+        #
+        # It provides methods to handle connection livecycle (dead, alive, healthy).
+        #
+        class Connection
+          DEFAULT_RESURRECT_TIMEOUT = 60
+
+          attr_reader :host, :connection, :options, :failures, :dead_since
+
+          # @option arguments [Hash]   :host       Host information (example: `{host: 'localhost', port: 9200}`)
+          # @option arguments [Object] :connection The transport-specific physical connection or "session"
+          # @option arguments [Hash]   :options    Options (usually passed in from transport)
+          #
+          def initialize(arguments = {})
+            @host       = arguments[:host].is_a?(Hash) ? Redacted.new(arguments[:host]) : arguments[:host]
+            @connection = arguments[:connection]
+            @options    = arguments[:options] || {}
+            @state_mutex = Mutex.new
+
+            @options[:resurrect_timeout] ||= DEFAULT_RESURRECT_TIMEOUT
+            @dead = false
+            @failures = 0
+          end
+
+          # Returns the complete endpoint URL with host, port, path and serialized parameters.
+          #
+          # @return [String]
+          #
+          def full_url(path, params = {})
+            url  = "#{host[:protocol]}://"
+            url += "#{CGI.escape(host[:user])}:#{CGI.escape(host[:password])}@" if host[:user]
+            url += "#{host[:host]}:#{host[:port]}"
+            url += host[:path].to_s if host[:path]
+            full_path = full_path(path, params)
+            url += '/' unless full_path.match?(%r{^/})
+            url += full_path
+          end
+
+          # Returns the complete endpoint path with serialized parameters.
+          #
+          # @return [String]
+          #
+          def full_path(path, params = {})
+            path + (params.empty? ? '' : "?#{::Faraday::Utils::ParamsHash[params].to_query}")
+          end
+
+          # Returns true when this connection has been marked dead, false otherwise.
+          #
+          # @return [Boolean]
+          #
+          def dead?
+            @dead || false
+          end
+
+          # Marks this connection as dead, incrementing the `failures` counter and
+          # storing the current time as `dead_since`.
+          #
+          # @return [self]
+          #
+          def dead!
+            @state_mutex.synchronize do
+              @dead       = true
+              @failures  += 1
+              @dead_since = Time.now
+            end
+            self
+          end
+
+          # Marks this connection as alive, ie. it is eligible to be returned from the pool by the selector.
+          #
+          # @return [self]
+          #
+          def alive!
+            @state_mutex.synchronize do
+              @dead     = false
+            end
+            self
+          end
+
+          # Marks this connection as healthy, ie. a request has been successfully performed with it.
+          #
+          # @return [self]
+          #
+          def healthy!
+            @state_mutex.synchronize do
+              @dead     = false
+              @failures = 0
+            end
+            self
+          end
+
+          # Marks this connection as alive, if the required timeout has passed.
+          #
+          # @return [self,nil]
+          # @see    DEFAULT_RESURRECT_TIMEOUT
+          # @see    #resurrectable?
+          #
+          def resurrect!
+            alive! if resurrectable?
+          end
+
+          # Returns true if the connection is eligible to be resurrected as alive, false otherwise.
+          #
+          # @return [Boolean]
+          #
+          def resurrectable?
+            @state_mutex.synchronize do
+              Time.now > @dead_since + (@options[:resurrect_timeout] * (2**(@failures - 1)))
+            end
+          end
+
+          # Equality operator based on connection protocol, host, port and attributes
+          #
+          # @return [Boolean]
+          #
+          def ==(other)
+            host[:protocol] == other.host[:protocol] && \
+              host[:host] == other.host[:host] && \
+              host[:port].to_i == other.host[:port].to_i && \
+              host[:attributes] == other.host[:attributes]
+          end
+
+          # @return [String]
+          #
+          def to_s
+            "<#{self.class.name} host: #{host} (#{dead? ? "dead since #{dead_since}" : 'alive'})>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opensearch/transport/transport/connections/selector.rb

@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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 OpenSearch
+  module Transport
+    module Transport
+      module Connections
+        module Selector
+          # @abstract Common functionality for connection selector implementations.
+          #
+          module Base
+            attr_reader :connections
+
+            # @option arguments [Connections::Collection] :connections Collection with connections.
+            #
+            def initialize(arguments = {})
+              @connections = arguments[:connections]
+            end
+
+            # @abstract Selector strategies implement this method to
+            #           select and return a connection from the pool.
+            #
+            # @return [Connection]
+            #
+            def select(_options = {})
+              raise NoMethodError, "Implement this method in the selector implementation."
+            end
+          end
+
+          # "Random connection" selector strategy.
+          #
+          class Random
+            include Base
+
+            # Returns a random connection from the collection.
+            #
+            # @return [Connections::Connection]
+            #
+            def select(_options = {})
+              connections.to_a.send(defined?(RUBY_VERSION) && RUBY_VERSION > '1.9' ? :sample : :choice)
+            end
+          end
+
+          # "Round-robin" selector strategy (default).
+          #
+          class RoundRobin
+            include Base
+
+            # @option arguments [Connections::Collection] :connections Collection with connections.
+            #
+            def initialize(arguments = {})
+              super
+              @mutex = Mutex.new
+              @current = nil
+            end
+
+            # Returns the next connection from the collection, rotating them in round-robin fashion.
+            #
+            # @return [Connections::Connection]
+            #
+            def select(_options = {})
+              @mutex.synchronize do
+                conns = connections
+                if @current && (@current < conns.size - 1)
+                  @current += 1
+                else
+                  @current = 0
+                end
+                conns[@current]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opensearch/transport/transport/errors.rb

@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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 OpenSearch
+  module Transport
+    module Transport
+      # Generic client error
+      #
+      class Error < StandardError; end
+
+      # Reloading connections timeout (1 sec by default)
+      #
+      class SnifferTimeoutError < Timeout::Error; end
+
+      # Elasticsearch server error (HTTP status 5xx)
+      #
+      class ServerError < Error; end
+
+      module Errors; end
+
+      HTTP_STATUSES = {
+        300 => 'MultipleChoices',
+        301 => 'MovedPermanently',
+        302 => 'Found',
+        303 => 'SeeOther',
+        304 => 'NotModified',
+        305 => 'UseProxy',
+        307 => 'TemporaryRedirect',
+        308 => 'PermanentRedirect',
+
+        400 => 'BadRequest',
+        401 => 'Unauthorized',
+        402 => 'PaymentRequired',
+        403 => 'Forbidden',
+        404 => 'NotFound',
+        405 => 'MethodNotAllowed',
+        406 => 'NotAcceptable',
+        407 => 'ProxyAuthenticationRequired',
+        408 => 'RequestTimeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'LengthRequired',
+        412 => 'PreconditionFailed',
+        413 => 'RequestEntityTooLarge',
+        414 => 'RequestURITooLong',
+        415 => 'UnsupportedMediaType',
+        416 => 'RequestedRangeNotSatisfiable',
+        417 => 'ExpectationFailed',
+        418 => 'ImATeapot',
+        421 => 'TooManyConnectionsFromThisIP',
+        426 => 'UpgradeRequired',
+        429 => 'TooManyRequests',
+        450 => 'BlockedByWindowsParentalControls',
+        494 => 'RequestHeaderTooLarge',
+        497 => 'HTTPToHTTPS',
+        499 => 'ClientClosedRequest',
+
+        500 => 'InternalServerError',
+        501 => 'NotImplemented',
+        502 => 'BadGateway',
+        503 => 'ServiceUnavailable',
+        504 => 'GatewayTimeout',
+        505 => 'HTTPVersionNotSupported',
+        506 => 'VariantAlsoNegotiates',
+        510 => 'NotExtended'
+      }
+
+      ERRORS = HTTP_STATUSES.each_with_object({}) do |error, sum|
+        status, name = error
+        sum[status] = Errors.const_set name, Class.new(ServerError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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 OpenSearch
+  module Transport
+    module Transport
+      module HTTP
+        # Alternative HTTP transport implementation, using the [_Curb_](https://rubygems.org/gems/curb) client.
+        #
+        # @see Transport::Base
+        #
+        class Curb
+          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, headers = nil, opts = {})
+            super do |connection, _url|
+              connection.connection.url = connection.full_url(path, params)
+
+              case method
+              when 'HEAD'
+                connection.connection.set :nobody, true
+              when 'GET', 'POST', 'PUT', 'DELETE'
+                connection.connection.set :nobody, false
+                connection.connection.put_data = __convert_to_json(body) if body
+                if headers
+                  if connection.connection.headers
+                    connection.connection.headers.merge!(headers)
+                  else
+                    connection.connection.headers = headers
+                  end
+                end
+              else
+                raise ArgumentError, "Unsupported HTTP method: #{method}"
+              end
+
+              connection.connection.http(method.to_sym)
+
+              Response.new(
+                connection.connection.response_code,
+                decompress_response(connection.connection.body_str),
+                headers(connection)
+              )
+            end
+          end
+
+          def headers(connection)
+            headers_string = connection.connection.header_str
+            return nil if headers_string.nil?
+
+            response_headers = headers_string&.split(/\\r\\n|\r\n/)&.reject(&:empty?)
+            response_headers.shift # Removes HTTP status string
+            processed_header = response_headers.flat_map { |s| s.scan(/^(\S+): (.+)/) }
+            headers_hash = processed_header.to_h.transform_keys(&:downcase)
+            if headers_hash['content-type']&.match?(%r{application/json})
+              headers_hash['content-type'] = 'application/json'
+            end
+            headers_hash
+          end
+
+          # Builds and returns a connection
+          #
+          # @return [Connections::Connection]
+          #
+          def __build_connection(host, options = {}, block = nil)
+            client = ::Curl::Easy.new
+            apply_headers(client, options)
+            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
+
+            client.instance_eval(&block) if block
+
+            Connections::Connection.new host: host, connection: client
+          end
+
+          # Returns an array of implementation specific connection errors.
+          #
+          # @return [Array]
+          #
+          def host_unreachable_exceptions
+            [
+              ::Curl::Err::HostResolutionError,
+              ::Curl::Err::ConnectionFailedError,
+              ::Curl::Err::GotNothingError,
+              ::Curl::Err::RecvError,
+              ::Curl::Err::SendError,
+              ::Curl::Err::TimeoutError
+            ]
+          end
+
+          private
+
+          def user_agent_header(_client)
+            @user_agent_header ||= begin
+              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
+              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
+              end
+              meta << "Curb #{Curl::CURB_VERSION}"
+              "opensearch-ruby/#{VERSION} (#{meta.join('; ')})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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 OpenSearch
+  module Transport
+    module Transport
+      module HTTP
+        # The default transport implementation, using the [_Faraday_](https://rubygems.org/gems/faraday)
+        # library for abstracting the HTTP client.
+        #
+        # @see Transport::Base
+        #
+        class Faraday
+          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, headers = nil, opts = {})
+            super do |connection, url|
+              headers = if connection.connection.headers
+                          if headers.nil?
+                            connection.connection.headers
+                          else
+                            connection.connection.headers.merge(headers)
+                          end
+                        else
+                          headers
+                        end
+
+              response = connection.connection.run_request(
+                method.downcase.to_sym,
+                url,
+                (body ? __convert_to_json(body) : nil),
+                headers
+              )
+
+              Response.new response.status, decompress_response(response.body), response.headers
+            end
+          end
+
+          # Builds and returns a connection
+          #
+          # @return [Connections::Connection]
+          #
+          def __build_connection(host, options = {}, block = nil)
+            client = ::Faraday.new(__full_url(host), options, &block)
+            apply_headers(client, options)
+            Connections::Connection.new host: host, connection: client
+          end
+
+          # Returns an array of implementation specific connection errors.
+          #
+          # @return [Array]
+          #
+          def host_unreachable_exceptions
+            [::Faraday::ConnectionFailed, ::Faraday::TimeoutError]
+          end
+
+          private
+
+          def user_agent_header(client)
+            @user_agent_header ||= begin
+              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
+              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
+              end
+              meta << client.headers[USER_AGENT_STR].to_s
+              "opensearch-ruby/#{VERSION} (#{meta.join('; ')})"
+            end
+          end
+        end
+      end
+    end
+  end
+end