algolia 2.0.0.pre.alpha.2

data/lib/algolia/transport/request_options.rb

@@ -0,0 +1,94 @@
+module Algolia
+  module Transport
+    class RequestOptions
+      attr_accessor :headers, :params, :data, :timeout, :connect_timeout, :compression_type
+
+      # @param [Search::Config] config
+      #
+      def initialize(config)
+        @headers          = {}
+        @params           = {}
+        @data             = {}
+        @timeout          = nil
+        @connect_timeout  = nil
+        @compression_type = config.compression_type
+      end
+
+      # Create and format headers and params from request options
+      #
+      # @param opts [Hash]
+      #
+      def create(opts = {})
+        add_headers(opts)
+        add_params(opts)
+        add_timeout(opts)
+        add_connect_timeout(opts)
+        add_compression_type(opts)
+        add_data_body(opts)
+      end
+
+      # Add or update headers
+      #
+      # @param opts [Hash]
+      #
+      def add_headers(opts = {})
+        unless opts[:headers].nil?
+          opts[:headers].each do |opt, value|
+            @headers[opt.to_sym] = value
+          end
+          opts.delete(:headers)
+        end
+      end
+
+      # Add or update query parameters
+      #
+      # @param opts [Hash]
+      #
+      def add_params(opts = {})
+        unless opts[:params].nil?
+          opts[:params].each do |opt, value|
+            @params[opt.to_sym] = value
+          end
+          opts.delete(:params)
+        end
+      end
+
+      # Add or update timeout
+      #
+      # @param opts [Hash]
+      #
+      def add_timeout(opts = {})
+        @timeout = opts[:timeout] || @timeout
+        opts.delete(:timeout)
+      end
+
+      # Add or update connect timeout
+      #
+      # @param opts [Hash]
+      #
+      def add_connect_timeout(opts = {})
+        @connect_timeout = opts[:connect_timeout] || @connect_timeout
+        opts.delete(:connect_timeout)
+      end
+
+      # Add or update compression_type
+      #
+      # @param opts [Hash]
+      #
+      def add_compression_type(opts = {})
+        @compression_type = opts[:compression_type] || @compression_type
+        opts.delete(:compression_type)
+      end
+
+      # @param opts [Hash]
+      #
+      def add_data_body(opts = {})
+        unless opts.empty?
+          opts.each do |key, value|
+            @data[key.to_sym] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/algolia/transport/retry_strategy.rb

@@ -0,0 +1,117 @@
+module Algolia
+  module Transport
+    # Class RetryStatregy
+    class RetryStrategy
+      include RetryOutcomeType
+
+      # @param config [Search::Config] config which contains the hosts
+      #
+      def initialize(config)
+        @hosts = config.default_hosts
+        @lock  = Mutex.new
+      end
+
+      # Retrieves the tryable hosts
+      #
+      # @param call_type [binary] type of the host
+      #
+      # @return [Array] list of StatefulHost
+      #
+      def get_tryable_hosts(call_type)
+        @lock.synchronize do
+          reset_expired_hosts
+
+          if @hosts.any? { |host| host.up && flag?(host.accept, call_type) }
+            @hosts.select { |host| host.up && flag?(host.accept, call_type) }
+          else
+            @hosts.each do |host|
+              reset(host) if flag?(host.accept, call_type)
+            end
+            @hosts
+          end
+        end
+      end
+
+      # Decides on the outcome of the request
+      #
+      # @param tryable_host [StatefulHost] host to test against
+      # @param http_response_code [Integer] http response code
+      # @param is_timed_out [Boolean] whether or not the request timed out
+      #
+      # @return [Binary] retry outcome code
+      #
+      def decide(tryable_host, http_response_code: nil, is_timed_out: false, network_failure: false)
+        @lock.synchronize do
+          if !is_timed_out && success?(http_response_code)
+            tryable_host.up       = true
+            tryable_host.last_use = Time.now.utc
+            SUCCESS
+          elsif !is_timed_out && retryable?(http_response_code, network_failure)
+            tryable_host.up       = false
+            tryable_host.last_use = Time.now.utc
+            RETRY
+          elsif is_timed_out
+            tryable_host.up           = true
+            tryable_host.last_use     = Time.now.utc
+            tryable_host.retry_count += 1
+            RETRY
+          else
+            FAILURE
+          end
+        end
+      end
+
+      private
+
+      # @param http_response_code [Integer]
+      #
+      # @return [Boolean]
+      #
+      def success?(http_response_code)
+        !http_response_code.nil? && (http_response_code.to_i / 100).floor == 2
+      end
+
+      # @param http_response_code [Integer]
+      #
+      # @return [Boolean]
+      #
+      def retryable?(http_response_code, network_failure)
+        if network_failure
+          return true
+        end
+
+        !http_response_code.nil? && (http_response_code.to_i / 100).floor != 2 && (http_response_code.to_i / 100).floor != 4
+      end
+
+      # Iterates in the hosts list and reset the ones that are down
+      #
+      def reset_expired_hosts
+        @hosts.each do |host|
+          host_last_usage = Time.now.utc - host.last_use
+          reset(host) if !host.up && host_last_usage.to_i > Defaults::TTL
+        end
+      end
+
+      # Reset a single host
+      #
+      # @param host [StatefulHost]
+      #
+      def reset(host)
+        host.up          = true
+        host.retry_count = 0
+        host.last_use    = Time.now.utc
+      end
+
+      # Make a binary check to know whether the item contains the flag
+      #
+      # @param item [binary] item to check
+      # @param flag [binary] flag to find in the item
+      #
+      # @return [Boolean]
+      #
+      def flag?(item, flag)
+        (item & (1 << (flag - 1))) > 0
+      end
+    end
+  end
+end

data/lib/algolia/transport/stateful_host.rb

@@ -0,0 +1,26 @@
+module Algolia
+  module Transport
+    # Class StatefulHost
+    class StatefulHost
+      include CallType
+
+      attr_reader :url, :protocol, :accept
+      attr_accessor :last_use, :retry_count, :up
+
+      # @param url [String] host url
+      # @option options [binary] :accept accept type flag
+      # @option options [DateTime] :last_use last usage date
+      # @option options [Integer] :retry_count number of retries
+      # @option options [Boolean] :up host status
+      #
+      def initialize(url, opts = {})
+        @url         = url
+        @protocol    = opts[:protocol] || 'https://'
+        @accept      = opts[:accept] || (READ | WRITE)
+        @last_use    = opts[:last_use] || Time.now.utc
+        @retry_count = opts[:retry_count] || 0
+        @up          = opts.has_key?(:up) ? opts[:up] : true
+      end
+    end
+  end
+end

data/lib/algolia/transport/transport.rb

@@ -0,0 +1,161 @@
+require 'faraday'
+
+module Algolia
+  module Transport
+    class Transport
+      include RetryOutcomeType
+      include CallType
+      include Helpers
+
+      # @param config [Search::Config] config used for search
+      # @param requester [Object] requester used for sending requests. Uses Algolia::Http::HttpRequester by default
+      #
+      def initialize(config, requester)
+        @config           = config
+        @http_requester   = requester
+        @retry_strategy   = RetryStrategy.new(config)
+      end
+
+      # Build a request with call type READ
+      #
+      # @param method [Symbol] method used for request
+      # @param path [String] path of the request
+      # @param body [Hash] request body
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def read(method, path, body = {}, opts = {})
+        request(READ, method, path, body, opts)
+      end
+
+      # Build a request with call type WRITE
+      #
+      # @param method [Symbol] method used for request
+      # @param path [String] path of the request
+      # @param body [Hash] request body
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def write(method, path, body = {}, opts = {})
+        request(WRITE, method, path, body, opts)
+      end
+
+      # @param call_type [Binary] READ or WRITE operation
+      # @param method [Symbol] method used for request
+      # @param path [String] path of the request
+      # @param body [Hash] request body
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return [Response] response of the request
+      #
+      def request(call_type, method, path, body = {}, opts = {})
+        @retry_strategy.get_tryable_hosts(call_type).each do |host|
+          opts[:timeout]         ||= get_timeout(call_type) * (host.retry_count + 1)
+          opts[:connect_timeout] ||= @config.connect_timeout * (host.retry_count + 1)
+
+          request_options = RequestOptions.new(@config)
+          request_options.create(opts)
+          request_options.params.merge!(request_options.data) if method == :GET
+
+          request  = build_request(method, path, body, request_options)
+          response = @http_requester.send_request(
+            host,
+            request[:method],
+            request[:path],
+            request[:body],
+            request[:headers],
+            request[:timeout],
+            request[:connect_timeout]
+          )
+
+          outcome  = @retry_strategy.decide(host, http_response_code: response.status, is_timed_out: response.has_timed_out, network_failure: response.network_failure)
+          if outcome == FAILURE
+            decoded_error = json_to_hash(response.error, @config.symbolize_keys)
+            raise AlgoliaHttpError.new(get_option(decoded_error, 'status'), get_option(decoded_error, 'message'))
+          end
+          return json_to_hash(response.body, @config.symbolize_keys) unless outcome == RETRY
+        end
+
+        raise AlgoliaUnreachableHostError, 'Unreachable hosts'
+      end
+
+      private
+
+      # Parse the different information and build the request
+      #
+      # @param [Symbol] method
+      # @param [String] path
+      # @param [Hash] body
+      # @param [RequestOptions] request_options
+      #
+      # @return [Hash]
+      #
+      def build_request(method, path, body, request_options)
+        request           = {}
+        request[:method]  = method.downcase
+        request[:path]    = build_uri_path(path, request_options.params)
+        request[:body]    = build_body(body, request_options, method)
+        request[:headers] = generate_headers(request_options)
+        request
+      end
+
+      # Build the uri from path and additional params
+      #
+      # @param [Object] path
+      # @param [Object] params
+      #
+      # @return [String]
+      #
+      def build_uri_path(path, params)
+        path + handle_params(params)
+      end
+
+      # Build the body of the request
+      #
+      # @param [Hash] body
+      #
+      # @return [Hash]
+      #
+      def build_body(body, request_options, method)
+        if method == :GET && body.empty?
+          return nil
+        end
+
+        # merge optional special request options to the body when it
+        # doesn't have to be in the array format
+        body.merge!(request_options.data) if body.is_a?(Hash) && method != :GET
+        to_json(body)
+      end
+
+      # Generates headers from config headers and optional parameters
+      #
+      # @option options [String] :headers
+      #
+      # @return [Hash] merged headers
+      #
+      def generate_headers(request_options = {})
+        headers                                                     = {}
+        extra_headers                                               = request_options.headers || {}
+        @config.default_headers.each { |key, val| headers[key.to_s] = val }
+        extra_headers.each { |key, val| headers[key.to_s]           = val }
+        if request_options.compression_type == Defaults::GZIP_ENCODING
+          headers['Accept-Encoding']  = Defaults::GZIP_ENCODING
+        end
+        headers
+      end
+
+      # Retrieves a timeout according to call_type
+      #
+      # @param call_type [Binary] requested call type
+      #
+      # @return [Integer]
+      #
+      def get_timeout(call_type)
+        case call_type
+        when READ
+          @config.read_timeout
+        else
+          @config.write_timeout
+        end
+      end
+    end
+  end
+end

data/lib/algolia/user_agent.rb

@@ -0,0 +1,25 @@
+module Algolia
+  class UserAgent
+    attr_accessor :value
+
+    @@value = Defaults::USER_AGENT
+
+    # Set the value of the UserAgent
+    #
+    def self.value
+      @@value
+    end
+
+    # Resets the value of the UserAgent
+    #
+    def self.reset_to_default
+      @@value = Defaults::USER_AGENT
+    end
+
+    # Adds a segment to the UserAgent
+    #
+    def self.add(segment, version)
+      @@value += format('; %<segment>s (%<version>s)', segment: segment, version: version)
+    end
+  end
+end

data/lib/algolia/version.rb

@@ -0,0 +1,3 @@
+module Algolia
+  VERSION = '2.0.0-alpha.2'.freeze
+end

data/sig/config/algolia_config.rbs

@@ -0,0 +1,24 @@
+module Algolia
+  # Class AlgoliaConfig
+  class AlgoliaConfig
+    attr_accessor app_id: String
+
+    attr_accessor api_key: String
+
+    attr_accessor default_headers: Hash[String, String]
+
+    attr_accessor batch_size: Integer
+
+    attr_accessor read_timeout: Integer
+
+    attr_accessor write_timeout: Integer
+
+    attr_accessor connect_timeout: Integer
+
+    attr_accessor compression_type: String
+
+    attr_accessor symbolize_keys: bool
+
+    def initialize: (?::Hash[Symbol, String|[String]] opts) -> void
+  end
+end