http 6.0.0-java

data/lib/http/options.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "http/headers"
+require "openssl"
+require "socket"
+require "http/uri"
+
+module HTTP
+  # Configuration options for HTTP requests and clients
+  class Options
+    @default_socket_class     = TCPSocket
+    @default_ssl_socket_class = OpenSSL::SSL::SSLSocket
+    @default_timeout_class    = HTTP::Timeout::Null
+    @available_features       = {}
+
+    class << self
+      # Default TCP socket class
+      #
+      # @example
+      #   HTTP::Options.default_socket_class # => TCPSocket
+      #
+      # @return [Class] default socket class
+      # @api public
+      attr_accessor :default_socket_class
+
+      # Default SSL socket class
+      #
+      # @example
+      #   HTTP::Options.default_ssl_socket_class
+      #
+      # @return [Class] default SSL socket class
+      # @api public
+      attr_accessor :default_ssl_socket_class
+
+      # Default timeout handler class
+      #
+      # @example
+      #   HTTP::Options.default_timeout_class
+      #
+      # @return [Class] default timeout class
+      # @api public
+      attr_accessor :default_timeout_class
+
+      # Registered feature implementations
+      #
+      # @example
+      #   HTTP::Options.available_features
+      #
+      # @return [Hash] registered feature implementations
+      # @api public
+      attr_reader :available_features
+
+      # Returns existing Options or creates new one
+      #
+      # @example
+      #   HTTP::Options.new(response: :auto)
+      #
+      # @param [HTTP::Options, Hash, nil] options existing Options or Hash to convert
+      # @api public
+      # @return [HTTP::Options]
+      def new(options = nil, **kwargs)
+        return options if options.is_a?(self)
+
+        super(**(options || kwargs)) # steep:ignore
+      end
+
+      # Returns list of defined option names
+      #
+      # @example
+      #   HTTP::Options.defined_options
+      #
+      # @api semipublic
+      # @return [Array<Symbol>]
+      def defined_options
+        @defined_options ||= []
+      end
+
+      # Registers a feature by name and implementation
+      #
+      # @example
+      #   HTTP::Options.register_feature(:auto_inflate, AutoInflate)
+      #
+      # @param [Symbol] name
+      # @param [Class] impl
+      # @api public
+      # @return [Class]
+      def register_feature(name, impl)
+        @available_features[name] = impl
+      end
+
+      protected
+
+      # Defines an option with accessor and with_ method
+      #
+      # @param [Symbol] name
+      # @param [Boolean] reader_only
+      # @api private
+      # @return [void]
+      def def_option(name, reader_only: false, &interpreter)
+        defined_options << name.to_sym
+        interpreter ||= ->(v) { v }
+
+        def_option_accessor(name, reader_only: reader_only)
+
+        define_method(:"with_#{name}") do |value|
+          dup { |opts| opts.send(:"#{name}=", instance_exec(value, &interpreter)) } # steep:ignore
+        end
+      end
+
+      # Define accessor methods for an option
+      #
+      # @example
+      #   def_option_accessor(:timeout, reader_only: false)
+      #
+      # @return [void]
+      # @api private
+      def def_option_accessor(name, reader_only:)
+        if reader_only
+          attr_reader name
+        else
+          attr_accessor name
+          protected :"#{name}="
+        end
+      end
+    end
+
+    # Initializes options with keyword arguments
+    #
+    # @example
+    #   HTTP::Options.new(response: :auto, follow: true)
+    #
+    # @api public
+    # @return [HTTP::Options]
+    def initialize(
+      response: :auto,
+      encoding: nil,
+      nodelay: false,
+      keep_alive_timeout: 5,
+      proxy: {},
+      ssl: {},
+      headers: {},
+      features: {},
+      timeout_class: self.class.default_timeout_class,
+      timeout_options: {},
+      socket_class: self.class.default_socket_class,
+      ssl_socket_class: self.class.default_ssl_socket_class,
+      params: nil,
+      form: nil,
+      json: nil,
+      body: nil,
+      follow: nil,
+      retriable: nil,
+      base_uri: nil,
+      persistent: nil,
+      ssl_context: nil
+    )
+      assign_options(binding)
+    end
+
+    # Merges two Options objects
+    #
+    # @example
+    #   opts = HTTP::Options.new.merge(HTTP::Options.new(response: :body))
+    #
+    # @param [HTTP::Options, Hash] other
+    # @api public
+    # @return [HTTP::Options]
+    def merge(other)
+      merged = to_hash.merge(other.to_hash) do |k, v1, v2|
+        k == :headers ? v1.merge(v2) : v2
+      end
+
+      self.class.new(**merged)
+    end
+
+    # Converts options to a Hash
+    #
+    # @example
+    #   HTTP::Options.new.to_hash
+    #
+    # @api public
+    # @return [Hash]
+    def to_hash
+      self.class.defined_options.to_h { |opt_name| [opt_name, public_send(opt_name)] }
+    end
+
+    # Duplicates the options object
+    #
+    # @example
+    #   opts = HTTP::Options.new
+    #   opts.dup
+    #
+    # @api public
+    # @return [HTTP::Options]
+    def dup
+      dupped = super
+      yield(dupped) if block_given?
+      dupped
+    end
+
+    # Returns a feature by name
+    #
+    # @example
+    #   opts = HTTP::Options.new
+    #   opts.feature(:auto_inflate)
+    #
+    # @param [Symbol] name
+    # @api public
+    # @return [Feature, nil]
+    def feature(name)
+      features[name]
+    end
+
+    private
+
+    # Assigns all option values from the initialize binding
+    #
+    # @param [Binding] env binding from initialize with keyword argument values
+    # @api private
+    # @return [void]
+    def assign_options(env)
+      self.class.defined_options.each do |name|
+        value = env.local_variable_get(name)
+        value = Headers.coerce(value) if name.eql?(:headers)
+        __send__(:"#{name}=", value)
+      end
+    end
+
+    # Raises an argument error with adjusted backtrace
+    #
+    # @api private
+    # @return [void]
+    def argument_error!(message)
+      error = Error.new(message)
+      error.set_backtrace(caller(1) || [])
+      raise error
+    end
+  end
+end
+
+require "http/options/definitions"

data/lib/http/redirector.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "http/headers"
+
+module HTTP
+  # Follows HTTP redirects according to configured policy
+  class Redirector
+    # Notifies that we reached max allowed redirect hops
+    class TooManyRedirectsError < ResponseError; end
+
+    # Notifies that following redirects got into an endless loop
+    class EndlessRedirectError < TooManyRedirectsError; end
+
+    # HTTP status codes which indicate redirects
+    REDIRECT_CODES = [300, 301, 302, 303, 307, 308].to_set.freeze
+
+    # Codes which which should raise StateError in strict mode if original
+    # request was any of {UNSAFE_VERBS}
+    STRICT_SENSITIVE_CODES = [300, 301, 302].to_set.freeze
+
+    # Insecure http verbs, which should trigger StateError in strict mode
+    # upon {STRICT_SENSITIVE_CODES}
+    UNSAFE_VERBS = %i[put delete post].to_set.freeze
+
+    # Verbs which will remain unchanged upon See Other response.
+    SEE_OTHER_ALLOWED_VERBS = %i[get head].to_set.freeze
+
+    # Returns redirector policy
+    #
+    # @example
+    #   redirector.strict # => true
+    #
+    # @return [Boolean]
+    # @api public
+    attr_reader :strict
+
+    # Returns maximum allowed hops
+    #
+    # @example
+    #   redirector.max_hops # => 5
+    #
+    # @return [Fixnum]
+    # @api public
+    attr_reader :max_hops
+
+    # Initializes a new Redirector
+    #
+    # @example
+    #   HTTP::Redirector.new(strict: true, max_hops: 5)
+    #
+    # @param [Boolean] strict (true) redirector hops policy
+    # @param [#to_i] max_hops (5) maximum allowed amount of hops
+    # @param [#call, nil] on_redirect optional redirect callback
+    # @api public
+    # @return [HTTP::Redirector]
+    def initialize(strict: true, max_hops: 5, on_redirect: nil)
+      @strict      = strict
+      @max_hops    = Integer(max_hops)
+      @on_redirect = on_redirect
+    end
+
+    # Follows redirects until non-redirect response found
+    #
+    # @example
+    #   redirector.perform(request, response) { |req| client.perform(req) }
+    #
+    # @param [HTTP::Request] request
+    # @param [HTTP::Response] response
+    # @api public
+    # @return [HTTP::Response]
+    def perform(request, response, &)
+      @request  = request
+      @response = response
+      @visited  = []
+
+      follow_redirects(&) while REDIRECT_CODES.include?(@response.code)
+
+      @response
+    end
+
+    private
+
+    # Perform a single redirect step
+    #
+    # @api private
+    # @return [void]
+    def follow_redirects
+      @visited << visit_key
+
+      raise TooManyRedirectsError if too_many_hops?
+      raise EndlessRedirectError  if endless_loop?
+
+      @response.flush
+
+      @request = redirect_to(redirect_uri)
+      @on_redirect&.call @response, @request
+      @response = yield @request
+    end
+
+    # Extracts the redirect URI from the Location header
+    #
+    # @api private
+    # @return [String, nil] URI string or nil if no Location header
+    def redirect_uri
+      location = @response.headers.get(Headers::LOCATION)
+      location.join unless location.empty?
+    end
+
+    # Check if we reached max amount of redirect hops
+    #
+    # @api private
+    # @return [Boolean]
+    def too_many_hops?
+      @max_hops.positive? && @visited.length > @max_hops
+    end
+
+    # Check if we got into an endless loop
+    #
+    # @api private
+    # @return [Boolean]
+    def endless_loop?
+      @visited.count(@visited.last) > 1
+    end
+
+    # Build a visit key for the current request
+    #
+    # Includes verb, URI, and Cookie header so that requests to the same URL
+    # with different cookies are not falsely detected as an endless loop.
+    #
+    # @api private
+    # @return [String]
+    def visit_key
+      "#{@request.verb} #{@request.uri} #{@request.headers[Headers::COOKIE]}"
+    end
+
+    # Redirect policy for follow
+    #
+    # @api private
+    # @return [Request]
+    def redirect_to(uri)
+      raise StateError, "no Location header in redirect" unless uri
+
+      verb = @request.verb
+      code = @response.code
+
+      if UNSAFE_VERBS.include?(verb) && STRICT_SENSITIVE_CODES.include?(code)
+        raise StateError, "can't follow #{@response.status} redirect" if @strict
+
+        verb = :get
+      end
+
+      verb = :get if !SEE_OTHER_ALLOWED_VERBS.include?(verb) && code.eql?(303)
+
+      @request.redirect(uri, verb)
+    end
+  end
+end

data/lib/http/request/body.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module HTTP
+  class Request
+    # Represents an HTTP request body with streaming support
+    class Body
+      # The source data for this body
+      #
+      # @example
+      #   body.source # => "hello world"
+      #
+      # @return [String, Enumerable, IO, nil]
+      # @api public
+      attr_reader :source
+
+      # Initialize a new request body
+      #
+      # @example
+      #   Body.new("hello world")
+      #
+      # @return [HTTP::Request::Body]
+      # @api public
+      def initialize(source)
+        @source = source
+
+        validate_source_type!
+      end
+
+      # Whether the body is empty
+      #
+      # @example
+      #   body.empty? # => true
+      #
+      # @return [Boolean]
+      # @api public
+      def empty?
+        @source.nil?
+      end
+
+      # Whether the body content can be accessed for logging
+      #
+      # Returns true for String sources (the content can be inspected).
+      # Returns false for IO streams and Enumerables (which cannot be
+      # read without consuming them), and for nil bodies.
+      #
+      # The logging feature checks the string encoding separately to
+      # decide whether to log the content as text or format it as binary.
+      #
+      # @example
+      #   body.loggable? # => true
+      #
+      # @return [Boolean]
+      # @api public
+      def loggable?
+        @source.is_a?(String)
+      end
+
+      # Returns size for the "Content-Length" header
+      #
+      # @example
+      #   body.size
+      #
+      # @return [Integer]
+      # @api public
+      def size
+        if @source.is_a?(String)
+          @source.bytesize
+        elsif @source.respond_to?(:read)
+          raise RequestError, "IO object must respond to #size" unless @source.respond_to?(:size)
+
+          @source.size
+        elsif @source.nil?
+          0
+        else
+          raise RequestError,
+                "cannot determine size of body: #{@source.inspect}; " \
+                "set the Content-Length header explicitly or use chunked Transfer-Encoding"
+        end
+      end
+
+      # Yields chunks of content to be streamed
+      #
+      # @example
+      #   body.each { |chunk| socket.write(chunk) }
+      #
+      # @yieldparam [String]
+      # @return [self]
+      # @api public
+      def each(&block)
+        if @source.is_a?(String)
+          yield @source
+        elsif @source.respond_to?(:read)
+          IO.copy_stream(@source, ProcIO.new(block))
+          rewind(@source)
+        elsif @source
+          @source.each(&block)
+        end
+
+        self
+      end
+
+      # Check equality based on source
+      #
+      # @example
+      #   body == other_body
+      #
+      # @return [Boolean]
+      # @api public
+      def ==(other)
+        other.is_a?(self.class) && source == other.source
+      end
+
+      private
+
+      # Rewind an IO source if possible
+      # @return [void]
+      # @api private
+      def rewind(io)
+        io.rewind if io.respond_to? :rewind
+      rescue Errno::ESPIPE, Errno::EPIPE
+        # Pipe IOs respond to `:rewind` but fail when you call it.
+        #
+        # Calling `IO#rewind` on a pipe, fails with *ESPIPE* on MRI,
+        # but *EPIPE* on jRuby.
+        #
+        # - **ESPIPE** -- "Illegal seek."
+        #   Invalid seek operation (such as on a pipe).
+        #
+        # - **EPIPE** -- "Broken pipe."
+        #   There is no process reading from the other end of a pipe. Every
+        #   library function that returns this error code also generates
+        #   a SIGPIPE signal; this signal terminates the program if not handled
+        #   or blocked. Thus, your program will never actually see EPIPE unless
+        #   it has handled or blocked SIGPIPE.
+        #
+        # See: https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html
+        nil
+      end
+
+      # Validate that source is a supported type
+      # @return [void]
+      # @api private
+      def validate_source_type!
+        return if @source.is_a?(String)
+        return if @source.respond_to?(:read)
+        return if @source.is_a?(Enumerable)
+        return if @source.nil?
+
+        raise RequestError, "body of wrong type: #{@source.class}"
+      end
+
+      # This class provides a "writable IO" wrapper around a proc object, with
+      # #write simply calling the proc, which we can pass in as the
+      # "destination IO" in IO.copy_stream.
+      class ProcIO
+        # Initialize a new ProcIO wrapper
+        #
+        # @example
+        #   ProcIO.new(block)
+        #
+        # @return [ProcIO]
+        # @api public
+        def initialize(block)
+          @block = block
+        end
+
+        # Write data by calling the wrapped proc
+        #
+        # @example
+        #   proc_io.write("hello")
+        #
+        # @return [Integer]
+        # @api public
+        def write(data)
+          @block.call(data)
+          data.bytesize
+        end
+      end
+    end
+  end
+end