http 6.0.0-java

data/lib/http/client.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "http/form_data"
+require "http/retriable/performer"
+require "http/options"
+require "http/feature"
+require "http/headers"
+require "http/connection"
+require "http/redirector"
+require "http/request/builder"
+require "http/uri"
+
+module HTTP
+  # Clients make requests and receive responses
+  class Client
+    extend Forwardable
+    include Chainable
+
+    # Initialize a new HTTP Client
+    #
+    # @example
+    #   client = HTTP::Client.new(headers: {"Accept" => "application/json"})
+    #
+    # @param default_options [HTTP::Options, nil] existing options instance
+    # @param options [Hash] keyword options (see HTTP::Options#initialize)
+    # @return [HTTP::Client] a new client instance
+    # @api public
+    def initialize(default_options = nil, **)
+      @default_options = HTTP::Options.new(default_options, **)
+      @connection = nil
+      @state = :clean
+    end
+
+    # Make an HTTP request
+    #
+    # @example
+    #   client.request(:get, "https://example.com")
+    #
+    # @param verb [Symbol] the HTTP method
+    # @param uri [#to_s] the URI to request
+    # @return [HTTP::Response] the response
+    # @api public
+    def request(verb, uri,
+                headers: nil, params: nil, form: nil, json: nil, body: nil,
+                response: nil, encoding: nil, follow: nil, ssl: nil, ssl_context: nil,
+                proxy: nil, nodelay: nil, features: nil, retriable: nil,
+                socket_class: nil, ssl_socket_class: nil, timeout_class: nil,
+                timeout_options: nil, keep_alive_timeout: nil, base_uri: nil, persistent: nil)
+      opts = { headers: headers, params: params, form: form, json: json, body: body,
+               response: response, encoding: encoding, follow: follow, ssl: ssl,
+               ssl_context: ssl_context, proxy: proxy, nodelay: nodelay, features: features,
+               retriable: retriable, socket_class: socket_class, ssl_socket_class: ssl_socket_class,
+               timeout_class: timeout_class, timeout_options: timeout_options,
+               keep_alive_timeout: keep_alive_timeout, base_uri: base_uri, persistent: persistent }.compact
+      opts = @default_options.merge(opts)
+      builder = Request::Builder.new(opts)
+      req     = builder.build(verb, uri)
+      res     = perform(req, opts)
+      return res unless opts.follow
+
+      Redirector.new(**opts.follow).perform(req, res) do |request|
+        perform(builder.wrap(request), opts)
+      end
+    end
+
+    # @!method persistent?
+    #   Indicate whether the client has persistent connections
+    #
+    #   @example
+    #     client.persistent?
+    #
+    #   @see Options#persistent?
+    #   @return [Boolean] whenever client is persistent
+    #   @api public
+    def_delegator :default_options, :persistent?
+
+    # Perform a single (no follow) HTTP request
+    #
+    # @example
+    #   client.perform(request, options)
+    #
+    # @param req [HTTP::Request] the request to perform
+    # @param options [HTTP::Options] request options
+    # @return [HTTP::Response] the response
+    # @api public
+    def perform(req, options)
+      if options.retriable
+        perform_with_retry(req, options)
+      else
+        perform_once(req, options)
+      end
+    end
+
+    # Close the connection and reset state
+    #
+    # @example
+    #   client.close
+    #
+    # @return [void]
+    # @api public
+    def close
+      @connection&.close
+      @connection = nil
+      @state = :clean
+    end
+
+    private
+
+    # Execute a single HTTP request without retry logic
+    #
+    # @param req [HTTP::Request] the request to perform
+    # @param options [HTTP::Options] request options
+    # @return [HTTP::Response] the response
+    # @api private
+    def perform_once(req, options)
+      res = perform_exchange(req, options)
+
+      @connection.finish_response if res.request.verb == :head
+      @state = :clean
+
+      res
+    rescue
+      close
+      raise
+    end
+
+    # Execute a request with retry logic
+    #
+    # @param req [HTTP::Request] the request to perform
+    # @param options [HTTP::Options] request options
+    # @return [HTTP::Response] the response
+    # @api private
+    def perform_with_retry(req, options)
+      Retriable::Performer.new(**options.retriable).perform(self, req) do
+        perform_once(req, options)
+      end
+    end
+
+    # Send request over the connection, handling proxy and errors
+    # @return [void]
+    # @api private
+    def send_request(req, options)
+      notify_features(req, options)
+
+      @connection ||= HTTP::Connection.new(req, options)
+
+      unless @connection.failed_proxy_connect?
+        @connection.send_request(req)
+        @connection.read_headers!
+      end
+    rescue Error => e
+      options.features.each_value { |feature| feature.on_error(req, e) }
+      raise
+    end
+
+    # Build response and apply feature wrapping
+    # @return [HTTP::Response] the wrapped response
+    # @api private
+    def build_wrapped_response(req, options)
+      res = build_response(req, options)
+
+      options.features.values.reverse.inject(res) do |response, feature|
+        feature.wrap_response(response)
+      end
+    end
+
+    # Notify features of an upcoming request attempt
+    # @return [void]
+    # @api private
+    def notify_features(req, options)
+      options.features.each_value { |feature| feature.on_request(req) }
+    end
+
+    # Execute the HTTP exchange wrapped by feature around_request hooks
+    # @return [HTTP::Response] the response
+    # @api private
+    def perform_exchange(req, options)
+      around_request(req, options) do |request|
+        verify_connection!(request.uri)
+        @state = :dirty
+        send_request(request, options)
+        build_wrapped_response(request, options)
+      end
+    end
+
+    # Compose around_request chains from all features
+    # @return [HTTP::Response] the response
+    # @api private
+    def around_request(request, options, &block)
+      options.features.values.reverse.reduce(block) do |inner, feature|
+        ->(req) { feature.around_request(req) { |r| inner.call(r) } }
+      end.call(request)
+    end
+
+    # Build a response from the current connection
+    # @return [HTTP::Response] the built response
+    # @api private
+    def build_response(req, options)
+      Response.new(
+        status:        @connection.status_code,
+        version:       @connection.http_version,
+        headers:       @connection.headers,
+        proxy_headers: @connection.proxy_response_headers,
+        connection:    @connection,
+        encoding:      options.encoding,
+        request:       req
+      ).tap { |res| @connection.pending_response = res }
+    end
+
+    # Verify our request isn't going to be made against another URI
+    #
+    # @return [void]
+    # @api private
+    def verify_connection!(uri)
+      if default_options.persistent? && uri.origin != default_options.persistent
+        raise StateError, "Persistence is enabled for #{default_options.persistent}, but we got #{uri.origin}"
+      end
+
+      # We re-create the connection object because we want to let prior requests
+      # lazily load the body as long as possible, and this mimics prior functionality.
+      return close if @connection && (!@connection.keep_alive? || @connection.expired?)
+
+      # If we get into a bad state (eg, Timeout.timeout ensure being killed)
+      # close the connection to prevent potential for mixed responses.
+      close if @state == :dirty
+    end
+  end
+end

data/lib/http/connection/internals.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module HTTP
+  class Connection
+    # Internal private methods for Connection
+    module Internals
+      private
+
+      # Flush the pending response body so the connection can be reused
+      # @return [void]
+      # @api private
+      def flush_pending_response
+        response = @pending_response
+        unless response.respond_to?(:flush)
+          close
+          return
+        end
+
+        flush_or_close_response(response)
+      rescue
+        close
+      end
+
+      # Flush the response or close if the body exceeds the size limit
+      # @param response [HTTP::Response] the response to flush
+      # @return [void]
+      # @api private
+      def flush_or_close_response(response)
+        content_length = response.content_length
+        if content_length && content_length > MAX_FLUSH_SIZE
+          close
+        else
+          response.flush
+        end
+      end
+
+      # Sets up SSL context and starts TLS if needed
+      # @param (see Connection#initialize)
+      # @return [void]
+      # @api private
+      def start_tls(req, options)
+        return unless req.uri.https? && !failed_proxy_connect?
+
+        ssl_context = options.ssl_context
+
+        unless ssl_context
+          ssl_context = OpenSSL::SSL::SSLContext.new
+          ssl_context.set_params(options.ssl || {})
+        end
+
+        @socket.start_tls(req.uri.host, options.ssl_socket_class, ssl_context)
+      end
+
+      # Open tunnel through proxy
+      # @return [void]
+      # @api private
+      def send_proxy_connect_request(req)
+        return unless req.uri.https? && req.using_proxy?
+
+        @pending_request = true
+
+        req.connect_using_proxy @socket
+
+        @pending_request  = false
+        @pending_response = true
+
+        read_headers!
+        handle_proxy_connect_response
+      end
+
+      # Process the proxy connect response
+      # @return [void]
+      # @api private
+      def handle_proxy_connect_response
+        @proxy_response_headers = @parser.headers
+
+        if @parser.status_code != 200
+          @failed_proxy_connect = true
+          return
+        end
+
+        @parser.reset
+        @pending_response = false
+      end
+
+      # Resets expiration of persistent connection
+      # @return [void]
+      # @api private
+      def reset_timer
+        @conn_expires_at = Time.now + @keep_alive_timeout if @persistent
+      end
+
+      # Store keep-alive state from parser
+      # @return [void]
+      # @api private
+      def set_keep_alive
+        return @keep_alive = false unless @persistent
+
+        @keep_alive =
+          case @parser.http_version
+          when HTTP_1_0 # HTTP/1.0 requires opt in for Keep Alive
+            @parser.headers[Headers::CONNECTION] == KEEP_ALIVE
+          when HTTP_1_1 # HTTP/1.1 is opt-out
+            @parser.headers[Headers::CONNECTION] != CLOSE
+          else # Anything else we assume doesn't support it
+            false
+          end
+      end
+
+      # Check if the response body has a known framing mechanism
+      #
+      # @example
+      #   body_framed?
+      #
+      # @return [Boolean]
+      # @api private
+      def body_framed?
+        @parser.headers.include?(Headers::TRANSFER_ENCODING) ||
+          @parser.headers.include?(Headers::CONTENT_LENGTH)
+      end
+
+      # Feeds some more data into parser
+      # @return [void]
+      # @raise [SocketReadError] when unable to read from socket
+      # @api private
+      def read_more(size)
+        return if @parser.finished?
+
+        value = @socket.readpartial(size, @buffer)
+        if value == :eof
+          @parser << ""
+          :eof
+        elsif value
+          @parser << value
+        end
+      rescue IOError, SocketError, SystemCallError => e
+        raise SocketReadError, "error reading from socket: #{e}", e.backtrace
+      end
+    end
+  end
+end

data/lib/http/connection.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "http/connection/internals"
+require "http/headers"
+
+module HTTP
+  # A connection to the HTTP server
+  class Connection
+    extend Forwardable
+    include Internals
+
+    # Allowed values for CONNECTION header
+    KEEP_ALIVE = "Keep-Alive"
+    # Connection: close header value
+    CLOSE      = "close"
+
+    # Attempt to read this much data
+    BUFFER_SIZE = 16_384
+
+    # Maximum response body size (in bytes) to auto-flush when reusing
+    # a connection. Bodies larger than this cause the connection to close
+    # instead, to avoid blocking on huge downloads.
+    MAX_FLUSH_SIZE = 1_048_576
+
+    # HTTP/1.0
+    HTTP_1_0 = "1.0"
+
+    # HTTP/1.1
+    HTTP_1_1 = "1.1"
+
+    # Returned after HTTP CONNECT (via proxy)
+    #
+    # @example
+    #   connection.proxy_response_headers
+    #
+    # @return [HTTP::Headers, nil]
+    # @api public
+    attr_reader :proxy_response_headers
+
+    # Initialize a new connection to an HTTP server
+    #
+    # @example
+    #   Connection.new(req, options)
+    #
+    # @param [HTTP::Request] req
+    # @param [HTTP::Options] options
+    # @return [Connection]
+    # @raise [HTTP::ConnectionError] when failed to connect
+    # @api public
+    def initialize(req, options)
+      init_state(options)
+      connect_socket(req, options)
+    rescue IO::TimeoutError => e
+      close
+      raise ConnectTimeoutError, e.message, e.backtrace
+    rescue IOError, SocketError, SystemCallError => e
+      raise ConnectionError, "failed to connect: #{e}", e.backtrace
+    rescue TimeoutError
+      close
+      raise
+    end
+
+    # @see (HTTP::Response::Parser#status_code)
+    def_delegator :@parser, :status_code
+
+    # @see (HTTP::Response::Parser#http_version)
+    def_delegator :@parser, :http_version
+
+    # @see (HTTP::Response::Parser#headers)
+    def_delegator :@parser, :headers
+
+    # Whether the proxy CONNECT request failed
+    #
+    # @example
+    #   connection.failed_proxy_connect?
+    #
+    # @return [Boolean] whenever proxy connect failed
+    # @api public
+    def failed_proxy_connect?
+      @failed_proxy_connect
+    end
+
+    # Set the pending response for auto-flushing before the next request
+    #
+    # @example
+    #   connection.pending_response = response
+    #
+    # @param [HTTP::Response, false] response
+    # @return [void]
+    # @api public
+    attr_writer :pending_response
+
+    # Send a request to the server
+    #
+    # @example
+    #   connection.send_request(req)
+    #
+    # @param [Request] req Request to send to the server
+    # @return [nil]
+    # @api public
+    def send_request(req)
+      flush_pending_response if @pending_response
+
+      if @pending_request
+        raise StateError, "Tried to send a request while a response is pending. Make sure you read off the body."
+      end
+
+      @pending_request = true
+
+      req.stream @socket
+
+      @pending_response = true
+      @pending_request  = false
+    end
+
+    # Read a chunk of the body
+    #
+    # @example
+    #   connection.readpartial
+    #
+    # @param [Integer] size maximum bytes to read
+    # @param [String, nil] outbuf buffer to fill with data
+    # @return [String] data chunk
+    # @raise [EOFError] when no more data left
+    # @api public
+    def readpartial(size = BUFFER_SIZE, outbuf = nil)
+      raise EOFError unless @pending_response
+
+      chunk = @parser.read(size)
+      unless chunk
+        eof = read_more(size) == :eof
+        check_premature_eof(eof)
+        finished = eof || @parser.finished?
+        chunk    = @parser.read(size) || "".b
+        finish_response if finished
+      end
+
+      outbuf ? outbuf.replace(chunk) : chunk
+    end
+
+    # Reads data from socket up until headers are loaded
+    #
+    # @example
+    #   connection.read_headers!
+    #
+    # @return [void]
+    # @raise [ResponseHeaderError] when unable to read response headers
+    # @api public
+    def read_headers!
+      until @parser.headers?
+        result = read_more(BUFFER_SIZE)
+        raise ResponseHeaderError, "couldn't read response headers" if result == :eof
+      end
+
+      set_keep_alive
+    end
+
+    # Callback for when we've reached the end of a response
+    #
+    # @example
+    #   connection.finish_response
+    #
+    # @return [void]
+    # @api public
+    def finish_response
+      close unless keep_alive?
+
+      @parser.reset
+      @socket.reset_counter if @socket.respond_to?(:reset_counter)
+      reset_timer
+
+      @pending_response = false
+    end
+
+    # Close the connection
+    #
+    # @example
+    #   connection.close
+    #
+    # @return [void]
+    # @api public
+    def close
+      @socket.close unless @socket&.closed?
+
+      @pending_response = false
+      @pending_request  = false
+    end
+
+    # Whether there are no pending requests or responses
+    #
+    # @example
+    #   connection.finished_request?
+    #
+    # @return [Boolean]
+    # @api public
+    def finished_request?
+      !@pending_request && !@pending_response
+    end
+
+    # Whether we're keeping the conn alive
+    #
+    # @example
+    #   connection.keep_alive?
+    #
+    # @return [Boolean]
+    # @api public
+    def keep_alive?
+      @keep_alive && !@socket.closed?
+    end
+
+    # Whether our connection has expired
+    #
+    # @example
+    #   connection.expired?
+    #
+    # @return [Boolean]
+    # @api public
+    def expired?
+      !@conn_expires_at || @conn_expires_at < Time.now
+    end
+
+    private
+
+    # Initialize connection state
+    # @return [void]
+    # @api private
+    def init_state(options)
+      @persistent           = options.persistent?
+      @keep_alive_timeout   = options.keep_alive_timeout.to_f
+      @pending_request      = false
+      @pending_response     = false
+      @failed_proxy_connect = false
+      @buffer               = "".b
+      @parser               = Response::Parser.new
+    end
+
+    # Check for premature end-of-file and raise if detected
+    #
+    # @example
+    #   check_premature_eof(:eof)
+    #
+    # @return [void]
+    # @api private
+    def check_premature_eof(eof)
+      return unless eof && !@parser.finished? && body_framed?
+
+      close
+      raise ConnectionError, "response body ended prematurely"
+    end
+
+    # Connect socket and set up proxy/TLS
+    # @return [void]
+    # @api private
+    def connect_socket(req, options)
+      @socket = options.timeout_class.new(**options.timeout_options) # steep:ignore
+      @socket.connect(options.socket_class, req.socket_host, req.socket_port, nodelay: options.nodelay)
+
+      send_proxy_connect_request(req)
+      start_tls(req, options)
+      reset_timer
+    end
+  end
+end