elasticsearch-transport-pixlee 1.0.13

data/lib/elasticsearch/transport/transport/connections/collection.rb

@@ -0,0 +1,93 @@
+module Elasticsearch
+  module Transport
+    module Transport
+      module Connections
+
+        # Wraps the collection of connections for the transport object as an Enumerable object.
+        #
+        # @see Base#connections
+        # @see Selector::Base#select
+        # @see Connection
+        #
+        class Collection
+          include Enumerable
+
+          DEFAULT_SELECTOR = Selector::RoundRobin
+
+          attr_reader :selector
+
+          # @option arguments [Array]    :connections    An array of {Connection} objects.
+          # @option arguments [Constant] :selector_class The class to be used as a connection selector strategy.
+          # @option arguments [Object]   :selector       The selector strategy object.
+          #
+          def initialize(arguments={})
+            selector_class = arguments[:selector_class] || DEFAULT_SELECTOR
+            @connections   = arguments[:connections]    || []
+            @selector      = arguments[:selector]       || selector_class.new(arguments.merge(:connections => self))
+          end
+
+          # Returns an Array of hosts information in this collection as Hashes.
+          #
+          # @return [Array]
+          #
+          def hosts
+            @connections.to_a.map { |c| c.host }
+          end
+
+          # Returns an Array of alive connections.
+          #
+          # @return [Array]
+          #
+          def connections
+            @connections.reject { |c| c.dead? }
+          end
+          alias :alive :connections
+
+          # Returns an Array of dead connections.
+          #
+          # @return [Array]
+          #
+          def dead
+            @connections.select { |c| c.dead? }
+          end
+
+          # Returns an Array of all connections, both dead and alive
+          #
+          # @return [Array]
+          #
+          def all
+            @connections
+          end
+
+          # Returns a connection.
+          #
+          # If there are no alive connections, resurrects a connection with least failures.
+          # Delegates to selector's `#select` method to get the connection.
+          #
+          # @return [Connection]
+          #
+          def get_connection(options={})
+            if connections.empty? && dead_connection = dead.sort { |a,b| a.failures <=> b.failures }.first
+              dead_connection.alive!
+            end
+            selector.select(options)
+          end
+
+          def each(&block)
+            connections.each(&block)
+          end
+
+          def slice(*args)
+            connections.slice(*args)
+          end
+          alias :[] :slice
+
+          def size
+            connections.size
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+module Elasticsearch
+  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]
+            @connection = arguments[:connection]
+            @options    = arguments[:options] || {}
+
+            @options[:resurrect_timeout] ||= DEFAULT_RESURRECT_TIMEOUT
+            @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 += "#{host[:user]}:#{host[:password]}@" if host[:user]
+            url += "#{host[:host]}:#{host[:port]}"
+            url += "#{host[:path]}" if host[:path]
+            url += "/#{full_path(path, params)}"
+          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!
+            @dead       = true
+            @failures  += 1
+            @dead_since = Time.now
+            self
+          end
+
+          # Marks this connection as alive, ie. it is eligible to be returned from the pool by the selector.
+          #
+          # @return [self]
+          #
+          def alive!
+            @dead     = false
+            self
+          end
+
+          # Marks this connection as healthy, ie. a request has been successfully performed with it.
+          #
+          # @return [self]
+          #
+          def healthy!
+            @dead     = false
+            @failures = 0
+            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?
+            Time.now > @dead_since + ( @options[:resurrect_timeout] * 2 ** (@failures-1) )
+          end
+
+          # @return [String]
+          #
+          def to_s
+            "<#{self.class.name} host: #{host} (#{dead? ? 'dead since ' + dead_since.to_s : 'alive'})>"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Elasticsearch
+  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
+
+            # Returns the next connection from the collection, rotating them in round-robin fashion.
+            #
+            # @return [Connections::Connection]
+            #
+            def select(options={})
+              # On Ruby 1.9, Array#rotate could be used instead
+              @current = @current.nil? ? 0 : @current+1
+              @current = 0 if @current >= connections.size
+              connections[@current]
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/transport/transport/errors.rb

@@ -0,0 +1,73 @@
+module Elasticsearch
+  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',
+        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.inject({}) do |sum, error|
+        status, name = error
+        sum[status] = Errors.const_set name, Class.new(ServerError)
+        sum
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Elasticsearch
+  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)
+            super do |connection,url|
+              connection.connection.url = url
+
+              case method
+                when 'HEAD'
+                when 'GET', 'POST', 'PUT', 'DELETE'
+                  connection.connection.put_data = __convert_to_json(body) if body
+                else raise ArgumentError, "Unsupported HTTP method: #{method}"
+              end
+
+              connection.connection.http(method.to_sym)
+
+              headers = {}
+              headers['content-type'] = 'application/json' if connection.connection.header_str =~ /\/json/
+
+              Response.new connection.connection.response_code,
+                           connection.connection.body_str,
+                           headers
+            end
+          end
+
+          # Builds and returns a collection of connections.
+          #
+          # @return [Connections::Collection]
+          #
+          def __build_connections
+            Connections::Collection.new \
+              :connections => hosts.map { |host|
+                host[:protocol]   = host[:scheme] || DEFAULT_PROTOCOL
+                host[:port]     ||= DEFAULT_PORT
+
+                client = ::Curl::Easy.new
+                client.headers      = {'User-Agent' => "Curb #{Curl::CURB_VERSION}"}
+                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
+              },
+              :selector_class => options[:selector_class],
+              :selector => options[:selector]
+          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
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Elasticsearch
+  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)
+            super do |connection, url|
+              response = connection.connection.run_request \
+                method.downcase.to_sym,
+                url,
+                ( body ? __convert_to_json(body) : nil ),
+                {}
+              Response.new response.status, response.body, response.headers
+            end
+          end
+
+          # Builds and returns a collection of connections.
+          #
+          # @return [Connections::Collection]
+          #
+          def __build_connections
+            Connections::Collection.new \
+              :connections => hosts.map { |host|
+                host[:protocol]   = host[:scheme] || DEFAULT_PROTOCOL
+                host[:port]     ||= DEFAULT_PORT
+                url               = __full_url(host)
+
+                Connections::Connection.new \
+                  :host => host,
+                  :connection => ::Faraday::Connection.new(url, (options[:transport_options] || {}), &@block )
+              },
+              :selector_class => options[:selector_class],
+              :selector => options[:selector]
+          end
+
+          # Returns an array of implementation specific connection errors.
+          #
+          # @return [Array]
+          #
+          def host_unreachable_exceptions
+            [::Faraday::Error::ConnectionFailed, ::Faraday::Error::TimeoutError]
+          end
+        end
+      end
+    end
+  end
+end