http 6.0.0-java

data/lib/http/request/builder.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "uri"
+
+require "http/form_data"
+require "http/headers"
+require "http/connection"
+require "http/uri"
+
+module HTTP
+  class Request
+    # Builds HTTP::Request objects from resolved options
+    #
+    # @example Build a request from options
+    #   options = HTTP::Options.new(headers: {"Accept" => "application/json"})
+    #   builder = HTTP::Request::Builder.new(options)
+    #   request = builder.build(:get, "https://example.com")
+    #
+    # @see Options
+    class Builder
+      # Pattern matching HTTP or HTTPS URI schemes
+      HTTP_OR_HTTPS_RE = %r{\Ahttps?://}i
+
+      # Initialize a new Request Builder
+      #
+      # @example
+      #   HTTP::Request::Builder.new(HTTP::Options.new)
+      #
+      # @param options [HTTP::Options] resolved request options
+      # @return [HTTP::Request::Builder]
+      # @api public
+      def initialize(options)
+        @options = options
+      end
+
+      # Build an HTTP request
+      #
+      # @example
+      #   builder.build(:get, "https://example.com")
+      #
+      # @param verb [Symbol] the HTTP method
+      # @param uri [#to_s] the URI to request
+      # @return [HTTP::Request] the built request object
+      # @api public
+      def build(verb, uri)
+        uri     = make_request_uri(uri)
+        headers = make_request_headers
+        body    = make_request_body(headers)
+
+        req = HTTP::Request.new(
+          verb:           verb,
+          uri:            uri,
+          uri_normalizer: @options.feature(:normalize_uri)&.normalizer,
+          proxy:          @options.proxy,
+          headers:        headers,
+          body:           body
+        )
+
+        wrap(req)
+      end
+
+      # Wrap a request through feature middleware
+      #
+      # @example
+      #   builder.wrap(redirect_request)
+      #
+      # @param request [HTTP::Request] the request to wrap
+      # @return [HTTP::Request] the wrapped request
+      # @api public
+      def wrap(request)
+        @options.features.inject(request) do |req, (_name, feature)|
+          feature.wrap_request(req)
+        end
+      end
+
+      private
+
+      # Merges query params if needed
+      #
+      # @param uri [#to_s] the URI to process
+      # @return [HTTP::URI] the constructed URI
+      # @api private
+      def make_request_uri(uri)
+        uri = uri.to_s
+
+        if @options.base_uri? && uri !~ HTTP_OR_HTTPS_RE
+          uri = resolve_against_base(uri)
+        elsif @options.persistent? && uri !~ HTTP_OR_HTTPS_RE
+          uri = "#{@options.persistent}#{uri}"
+        end
+
+        uri = HTTP::URI.parse uri
+
+        merge_query_params!(uri)
+
+        # Some proxies (seen on WEBrick) fail if URL has
+        # empty path (e.g. `http://example.com`) while it's RFC-compliant:
+        # http://tools.ietf.org/html/rfc1738#section-3.1
+        uri.path = "/" if uri.path.empty?
+
+        uri
+      end
+
+      # Resolve a relative URI against the configured base URI
+      #
+      # Ensures the base URI path has a trailing slash so that relative
+      # paths are appended rather than replacing the last path segment,
+      # per the convention described in RFC 3986 Section 5.
+      #
+      # @param uri [String] the relative URI to resolve
+      # @return [String] the resolved absolute URI
+      # @api private
+      def resolve_against_base(uri)
+        base = @options.base_uri or raise Error, "base_uri is not set"
+
+        unless base.path.end_with?("/")
+          base = base.dup
+          base.path = "#{base.path}/"
+        end
+
+        String(base.join(uri))
+      end
+
+      # Merge query parameters into URI
+      #
+      # @return [void]
+      # @api private
+      def merge_query_params!(uri)
+        return unless @options.params && !@options.params.empty?
+
+        existing = ::URI.decode_www_form(uri.query || "")
+        uri.query = ::URI.encode_www_form(existing.concat(@options.params.to_a))
+      end
+
+      # Creates request headers
+      #
+      # @return [HTTP::Headers] the constructed headers
+      # @api private
+      def make_request_headers
+        headers = @options.headers
+
+        # Tell the server to keep the conn open
+        headers[Headers::CONNECTION] = @options.persistent? ? Connection::KEEP_ALIVE : Connection::CLOSE
+
+        headers
+      end
+
+      # Create the request body object to send
+      #
+      # @return [String, HTTP::FormData, nil] the request body
+      # @api private
+      def make_request_body(headers)
+        if @options.body
+          @options.body
+        elsif @options.form
+          form = make_form_data(@options.form)
+          headers[Headers::CONTENT_TYPE] ||= form.content_type
+          form
+        elsif @options.json
+          make_json_body(@options.json, headers)
+        end
+      end
+
+      # Encode JSON body and set content type header
+      # @return [String] the encoded JSON body
+      # @api private
+      def make_json_body(data, headers)
+        body = MimeType[:json].encode data
+        headers[Headers::CONTENT_TYPE] ||= "application/json; charset=#{body.encoding.name.downcase}"
+        body
+      end
+
+      # Coerce form data into an HTTP::FormData object
+      # @return [HTTP::FormData::Multipart, HTTP::FormData::Urlencoded] form data
+      # @api private
+      def make_form_data(form)
+        return form if form.is_a? FormData::Multipart
+        return form if form.is_a? FormData::Urlencoded
+
+        FormData.create(form)
+      end
+    end
+  end
+end

data/lib/http/request/proxy.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module HTTP
+  class Request
+    # Proxy-related methods for HTTP requests
+    module Proxy
+      # Merges proxy headers into the request headers
+      #
+      # @example
+      #   request.include_proxy_headers
+      #
+      # @return [void]
+      # @api public
+      def include_proxy_headers
+        headers.merge!(proxy[:proxy_headers]) if proxy.key?(:proxy_headers)
+        include_proxy_authorization_header if using_authenticated_proxy?
+      end
+
+      # Compute and add the Proxy-Authorization header
+      #
+      # @example
+      #   request.include_proxy_authorization_header
+      #
+      # @return [void]
+      # @api public
+      def include_proxy_authorization_header
+        headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header
+      end
+
+      # Build the Proxy-Authorization header value
+      #
+      # @example
+      #   request.proxy_authorization_header
+      #
+      # @return [String]
+      # @api public
+      def proxy_authorization_header
+        digest = encode64(format("%s:%s", proxy.fetch(:proxy_username), proxy.fetch(:proxy_password)))
+        "Basic #{digest}"
+      end
+
+      # Setup tunnel through proxy for SSL request
+      #
+      # @example
+      #   request.connect_using_proxy(socket)
+      #
+      # @return [void]
+      # @api public
+      def connect_using_proxy(socket)
+        Writer.new(socket, nil, proxy_connect_headers, proxy_connect_header).connect_through_proxy
+      end
+
+      # Compute HTTP request header SSL proxy connection
+      #
+      # @example
+      #   request.proxy_connect_header
+      #
+      # @return [String]
+      # @api public
+      def proxy_connect_header
+        "CONNECT #{host}:#{port} HTTP/#{version}"
+      end
+
+      # Headers to send with proxy connect request
+      #
+      # @example
+      #   request.proxy_connect_headers
+      #
+      # @return [HTTP::Headers]
+      # @api public
+      def proxy_connect_headers
+        connect_headers = Headers.coerce(
+          Headers::HOST       => headers[Headers::HOST],
+          Headers::USER_AGENT => headers[Headers::USER_AGENT]
+        )
+
+        connect_headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header if using_authenticated_proxy?
+        connect_headers.merge!(proxy[:proxy_headers]) if proxy.key?(:proxy_headers)
+        connect_headers
+      end
+    end
+  end
+end

data/lib/http/request/writer.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "http/headers"
+
+module HTTP
+  class Request
+    # Streams HTTP requests to a socket
+    class Writer
+      # CRLF is the universal HTTP delimiter
+      CRLF = "\r\n"
+
+      # Chunked data terminator
+      ZERO = "0"
+
+      # End of a chunked transfer
+      CHUNKED_END = "#{ZERO}#{CRLF}#{CRLF}".freeze
+
+      # Initialize a new request writer
+      #
+      # @example
+      #   Writer.new(socket, body, headers, "GET / HTTP/1.1")
+      #
+      # @return [HTTP::Request::Writer]
+      # @api public
+      def initialize(socket, body, headers, headline)
+        @body           = body
+        @socket         = socket
+        @headers        = headers
+        @request_header = [headline]
+      end
+
+      # Adds headers to the request header array
+      #
+      # @example
+      #   writer.add_headers
+      #
+      # @return [void]
+      # @api public
+      def add_headers
+        @headers.each do |field, value|
+          @request_header << "#{field}: #{value}"
+        end
+      end
+
+      # Stream the request to a socket
+      #
+      # @example
+      #   writer.stream
+      #
+      # @return [void]
+      # @api public
+      def stream
+        add_headers
+        add_body_type_headers
+        send_request
+      end
+
+      # Send headers needed to connect through proxy
+      #
+      # @example
+      #   writer.connect_through_proxy
+      #
+      # @return [void]
+      # @api public
+      def connect_through_proxy
+        add_headers
+        write(join_headers)
+      end
+
+      # Adds content length or transfer encoding headers
+      #
+      # @example
+      #   writer.add_body_type_headers
+      #
+      # @return [void]
+      # @api public
+      def add_body_type_headers
+        return if @headers[Headers::CONTENT_LENGTH] || chunked? || (
+          @body.source.nil? && %w[GET HEAD DELETE CONNECT].any? do |method|
+            @request_header.fetch(0).start_with?("#{method} ")
+          end
+        )
+
+        @request_header << "#{Headers::CONTENT_LENGTH}: #{@body.size}"
+      end
+
+      # Joins headers into an HTTP request header string
+      #
+      # @example
+      #   writer.join_headers
+      #
+      # @return [String]
+      # @api public
+      def join_headers
+        # join the headers array with crlfs, stick two on the end because
+        # that ends the request header
+        @request_header.join(CRLF) + (CRLF * 2)
+      end
+
+      # Writes HTTP request data into the socket
+      #
+      # @example
+      #   writer.send_request
+      #
+      # @return [void]
+      # @api public
+      def send_request
+        each_chunk { |chunk| write chunk }
+      rescue Errno::EPIPE
+        # server doesn't need any more data
+        nil
+      end
+
+      # Yields chunks of request data for the socket
+      #
+      # It's important to send the request in a single write call when possible
+      # in order to play nicely with Nagle's algorithm. Making two writes in a
+      # row triggers a pathological case where Nagle is expecting a third write
+      # that never happens.
+      #
+      # @example
+      #   writer.each_chunk { |chunk| socket.write(chunk) }
+      #
+      # @return [void]
+      # @api public
+      def each_chunk
+        data = join_headers
+
+        @body.each do |chunk|
+          data << encode_chunk(chunk)
+          yield data
+          data.clear
+        end
+
+        yield data unless data.empty?
+
+        yield CHUNKED_END if chunked?
+      end
+
+      # Returns chunk encoded per Transfer-Encoding header
+      #
+      # @example
+      #   writer.encode_chunk("hello")
+      #
+      # @return [String]
+      # @api public
+      def encode_chunk(chunk)
+        if chunked?
+          chunk.bytesize.to_s(16) << CRLF << chunk << CRLF
+        else
+          chunk
+        end
+      end
+
+      # Returns true if using chunked transfer encoding
+      #
+      # @example
+      #   writer.chunked?
+      #
+      # @return [Boolean]
+      # @api public
+      def chunked?
+        @headers[Headers::TRANSFER_ENCODING].eql?(Headers::CHUNKED)
+      end
+
+      private
+
+      # Write data to the underlying socket
+      # @return [void]
+      # @raise [SocketWriteError] when unable to write to socket
+      # @api private
+      def write(data)
+        until data.empty?
+          length = @socket.write(data)
+          break unless data.bytesize > length
+
+          data = data.byteslice(length..-1)
+        end
+      rescue Errno::EPIPE
+        raise
+      rescue IOError, SocketError, SystemCallError => e
+        raise SocketWriteError, "error writing to socket: #{e}", e.backtrace
+      end
+    end
+  end
+end