elastic-transport 8.0.0.pre1

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

@@ -0,0 +1,120 @@
+# 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 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_headers = {}
+              response_headers['content-type'] = 'application/json' if connection.connection.header_str =~ /\/json/
+
+              Response.new connection.connection.response_code,
+                           decompress_response(connection.connection.body_str),
+                           response_headers
+            end
+          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 ||= 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}"
+              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# 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 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.merge(headers)
+                          else
+                            connection.connection.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,
+                ::Faraday.const_defined?(:ServerError) ? ::Faraday::ServerError : nil,
+                ::Faraday::SSLError
+            ].compact
+          end
+
+          private
+
+          def user_agent_header(client)
+            @user_agent ||= 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]}"
+              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# 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 'manticore'
+
+module Elastic
+  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
+
+          def initialize(arguments={}, &block)
+            @request_options = { headers: (arguments.dig(:transport_options, :headers) || {}) }
+            @manticore = build_client(arguments[:options] || {})
+            super(arguments, &block)
+          end
+
+          # Should just be run once at startup
+          def build_client(options={})
+            client_options = options[:transport_options] || {}
+            client_options[:ssl] = options[:ssl] || {}
+
+            @manticore = ::Manticore::Client.new(client_options)
+          end
+
+          # 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|
+              params[:body] = __convert_to_json(body) if body
+              params[:headers] = headers if headers
+              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
+            apply_headers(@request_options, options[:transport_options])
+            apply_headers(@request_options, options)
+
+            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
+
+                Connections::Connection.new \
+                  :host => host,
+                  :connection => @manticore
+              },
+              :selector_class => options[:selector_class],
+              :selector => options[:selector]
+          end
+
+          # Closes all connections by marking them as dead
+          # and closing the underlying HttpClient instances
+          #
+          # @return [Connections::Collection]
+          #
+          def __close_connections
+            # The Manticore adapter uses a single long-lived instance
+            # of Manticore::Client, so we don't close the connections.
+          end
+
+          # Returns an array of implementation specific connection errors.
+          #
+          # @return [Array]
+          #
+          def host_unreachable_exceptions
+            [
+              ::Manticore::Timeout,
+              ::Manticore::SocketException,
+              ::Manticore::ClientProtocolException,
+              ::Manticore::ResolutionFailure
+            ]
+          end
+
+          private
+
+          def apply_headers(request_options, options)
+            headers = options&.[](:headers) || {}
+            headers[CONTENT_TYPE_STR] = find_value(headers, CONTENT_TYPE_REGEX) || DEFAULT_CONTENT_TYPE
+            headers[USER_AGENT_STR] = find_value(headers, USER_AGENT_REGEX) || user_agent_header
+            headers[ACCEPT_ENCODING] = GZIP if use_compression?
+            request_options[:headers].merge!(headers)
+          end
+
+          def user_agent_header
+            @user_agent ||= begin
+              meta = ["RUBY_VERSION: #{JRUBY_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 << "Manticore #{::Manticore::VERSION}"
+              "elasticsearch-ruby/#{VERSION} (#{meta.join('; ')})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elastic/transport/transport/loggable.rb

@@ -0,0 +1,83 @@
+# 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 to encapsulate all logging functionality.
+  #
+  # @since 7.0.0
+  module Loggable
+    # Log a debug message.
+    #
+    # @example Log a debug message.
+    #   log_debug('Message')
+    #
+    # @param [ String ] message The message to log.
+    #
+    # @since 7.0.0
+    def log_debug(message)
+      logger.debug(message) if logger && logger.debug?
+    end
+
+    # Log an error message.
+    #
+    # @example Log an error message.
+    #   log_error('Message')
+    #
+    # @param [ String ] message The message to log.
+    #
+    # @since 7.0.0
+    def log_error(message)
+      logger.error(message) if logger && logger.error?
+    end
+
+    # Log a fatal message.
+    #
+    # @example Log a fatal message.
+    #   log_fatal('Message')
+    #
+    # @param [ String ] message The message to log.
+    #
+    # @since 7.0.0
+    def log_fatal(message)
+      logger.fatal(message) if logger && logger.fatal?
+    end
+
+    # Log an info message.
+    #
+    # @example Log an info message.
+    #   log_info('Message')
+    #
+    # @param [ String ] message The message to log.
+    #
+    # @since 7.0.0
+    def log_info(message)
+      logger.info(message) if logger && logger.info?
+    end
+
+    # Log a warn message.
+    #
+    # @example Log a warn message.
+    #   log_warn('Message')
+    #
+    # @param [ String ] message The message to log.
+    #
+    # @since 7.0.0
+    def log_warn(message)
+      logger.warn(message) if logger && logger.warn?
+    end
+  end
+end