puma 7.2.2-java → 8.0.0-java

data/lib/puma/minissl.rb

@@ -25,9 +25,6 @@ module Puma
         @engine = engine
         @peercert = nil
         @reuse = nil
-        @write_buffer = +''
-        @write_owed = 0
-        @write_owed_data = nil
       end
 
       # @!attribute [r] to_io
@@ -71,8 +68,9 @@ module Puma
 
           return output if output
 
-          queue_ciphertext
-          flush_write_buffer
+          while neg_data = @engine.extract
+            @socket.write neg_data
+          end
         end
       end
 
@@ -87,60 +85,52 @@ module Puma
       def read_nonblock(size, *_)
         # *_ is to deal with keyword args that were added
         # at some point (and being used in the wild)
-        output = engine_read_all
-        return output if output
-
-        raise IO::EAGAINWaitReadable unless flush_write_buffer_nonblock
-
-        data = @socket.read_nonblock(size, exception: false)
-        if data == :wait_readable || data == :wait_writable
-          # It would make more sense to let @socket.read_nonblock raise
-          # EAGAIN if necessary but it seems like it'll misbehave on Windows.
-          # I don't have a Windows machine to debug this so I can't explain
-          # exactly what's happening in that OS. Please let me know if you
-          # find out!
-          #
-          # In the meantime, we can emulate the correct behavior by
-          # capturing :wait_readable & :wait_writable and raising EAGAIN
-          # ourselves.
-          raise IO::EAGAINWaitReadable
-        elsif data.nil?
-          raise SSLError.exception "HTTP connection?" if bad_tlsv1_3?
-          return nil
-        end
+        while true
+          output = engine_read_all
+          return output if output
+
+          data = @socket.read_nonblock(size, exception: false)
+          if data == :wait_readable || data == :wait_writable
+            # It would make more sense to let @socket.read_nonblock raise
+            # EAGAIN if necessary but it seems like it'll misbehave on Windows.
+            # I don't have a Windows machine to debug this so I can't explain
+            # exactly whats happening in that OS. Please let me know if you
+            # find out!
+            #
+            # In the meantime, we can emulate the correct behavior by
+            # capturing :wait_readable & :wait_writable and raising EAGAIN
+            # ourselves.
+            raise IO::EAGAINWaitReadable
+          elsif data.nil?
+            raise SSLError.exception "HTTP connection?" if bad_tlsv1_3?
+            return nil
+          end
 
-        @engine.inject(data)
-        output = engine_read_all
-        return output if output
+          @engine.inject(data)
+          output = engine_read_all
 
-        queue_ciphertext
-        flush_write_buffer_nonblock
-        raise IO::EAGAINWaitReadable
-      end
+          return output if output
 
-      def write_pending?
-        !@write_buffer.empty?
+          while neg_data = @engine.extract
+            @socket.write neg_data
+          end
+        end
       end
 
       def write(data)
         return 0 if data.empty?
 
         data_size = data.bytesize
-
-        flush_write_buffer
-        if @write_owed_data && data.byteslice(0, @write_owed_data.bytesize).b == @write_owed_data
-          data = data.byteslice(@write_owed..-1)
-          @write_owed = 0
-          @write_owed_data = nil
-          return data_size if data.empty?
-        end
-
-        need = data.bytesize
+        need = data_size
 
         while true
           wrote = @engine.write data
-          queue_ciphertext
-          flush_write_buffer
+
+          enc_wr = +''
+          while (enc = @engine.extract)
+            enc_wr << enc
+          end
+          @socket.write enc_wr unless enc_wr.empty?
 
           need -= wrote
 
@@ -153,43 +143,34 @@ module Puma
       alias_method :syswrite, :write
       alias_method :<<, :write
 
-      # As with SSL_write, retry with the same data after IO::EAGAINWaitWritable
-      def write_nonblock(data, exception: true)
-        return 0 if data.empty?
-
-        @write_owed = 0 if @write_owed_data && data.byteslice(0, @write_owed_data.bytesize).b != @write_owed_data
+      # This is a temporary fix to deal with websockets code using
+      # write_nonblock.
 
-        if @write_owed == 0
-          @write_owed = @engine.write data
-          @write_owed_data = nil
-          queue_ciphertext
-        end
-
-        unless flush_write_buffer_nonblock
-          @write_owed_data ||= data.byteslice(0, @write_owed).b
-          raise IO::EAGAINWaitWritable if exception
-          return :wait_writable
-        end
-
-        wrote = @write_owed
-        @write_owed = 0
-        @write_owed_data = nil
-        wrote
-      end
-
-      def wait_writable(timeout = nil)
-        @socket.wait_writable timeout
+      # The problem with implementing it properly
+      # is that it means we'd have to have the ability to rewind
+      # an engine because after we write+extract, the socket
+      # write_nonblock call might raise an exception and later
+      # code would pass the same data in, but the engine would think
+      # it had already written the data in.
+      #
+      # So for the time being (and since write blocking is quite rare),
+      # go ahead and actually block in write_nonblock.
+      #
+      def write_nonblock(data, *_)
+        write data
       end
 
       def flush
-        flush_write_buffer
         @socket.flush
       end
 
       def close
         begin
-          queue_ciphertext unless @engine.shutdown
-          flush_write_buffer_nonblock
+          unless @engine.shutdown
+            while alert_data = @engine.extract
+              @socket.write alert_data
+            end
+          end
         rescue IOError, SystemCallError
           # nothing
         ensure
@@ -197,32 +178,6 @@ module Puma
         end
       end
 
-      def queue_ciphertext
-        while (enc = @engine.extract)
-          @write_buffer << enc
-        end
-      end
-      private :queue_ciphertext
-
-      def flush_write_buffer
-        return if @write_buffer.empty?
-
-        @socket.write @write_buffer
-        @write_buffer = +''
-      end
-      private :flush_write_buffer
-
-      def flush_write_buffer_nonblock
-        until @write_buffer.empty?
-          n = @socket.write_nonblock @write_buffer, exception: false
-          return false if n == :wait_writable
-
-          @write_buffer = @write_buffer.byteslice(n..-1)
-        end
-        true
-      end
-      private :flush_write_buffer_nonblock
-
       # @!attribute [r] peeraddr
       def peeraddr
         @socket.peeraddr

data/lib/puma/reactor.rb

@@ -34,7 +34,6 @@ module Puma
       @selector = ::NIO::Selector.new(NIO::Selector.backends.delete(backend))
       @input = Queue.new
       @timeouts = []
-      @timeout_keys = {}.compare_by_identity
       @block = block
       @reactor_size = 0
       @reactor_max = 0
@@ -78,13 +77,11 @@ module Puma
     def select_loop
       begin
         until @input.closed? && @input.empty?
-          requeue_moved_timeouts
-
           # Wakeup any registered object that receives incoming data.
           # Block until the earliest timeout or Selector#wakeup is called.
           timeout = (earliest = @timeouts.first) && earliest.timeout
           @selector.select(timeout) do |monitor|
-            monitor.interests = interests(monitor.value) unless wakeup!(monitor.value)
+            wakeup!(monitor.value)
           end
 
           # Wakeup all objects that timed out.
@@ -96,7 +93,7 @@ module Puma
               client = @input.pop
               register(client) if client.io_ok?
             end
-            @timeouts.sort_by! { |client| @timeout_keys[client] }
+            @timeouts.sort_by!(&:timeout_at)
           end
         end
       rescue StandardError => e
@@ -113,19 +110,14 @@ module Puma
 
     # Start monitoring the object.
     def register(client)
-      @selector.register(client.to_io, interests(client)).value = client
+      @selector.register(client.to_io, :r).value = client
       @reactor_size += 1
       @reactor_max = @reactor_size if @reactor_max < @reactor_size
       @timeouts << client
-      @timeout_keys[client] = client.timeout_at
     rescue ArgumentError
       # unreadable clients raise error when processed by NIO
     end
 
-    def interests(client)
-      client.write_pending? ? :w : :r
-    end
-
     # 'Wake up' a monitored object by calling the provided block.
     # Stop monitoring the object if the block returns `true`.
     def wakeup!(client)
@@ -133,31 +125,7 @@ module Puma
         @selector.deregister client.to_io
         @reactor_size -= 1
         @timeouts.delete client
-        @timeout_keys.delete client
-        true
-      elsif client.timeout_at < @timeout_keys[client]
-        @timeouts.delete client
-        requeue client
-        false
-      else
-        false
       end
     end
-
-    # `@timeouts` is sorted by the timeout each client had when it was queued.
-    # Timeouts that moved earlier are requeued in `wakeup!`. Timeouts that moved
-    # later are requeued here, once the client reaches the front.
-    def requeue_moved_timeouts
-      while (client = @timeouts.first) && @timeout_keys[client] < client.timeout_at
-        @timeouts.shift
-        requeue client
-      end
-    end
-
-    def requeue(client)
-      key = @timeout_keys[client] = client.timeout_at
-      index = @timeouts.bsearch_index { |c| @timeout_keys[c] > key } || @timeouts.size
-      @timeouts.insert index, client
-    end
   end
 end

data/lib/puma/{request.rb → response.rb}

@@ -12,7 +12,7 @@ module Puma
   # #handle_request, which is called in Server#process_client.
   # @version 5.0.3
   #
-  module Request # :nodoc:
+  module Response # :nodoc:
 
     # Single element array body: smaller bodies are written to io_buffer first,
     # then a single write from io_buffer. Larger sizes are written separately.
@@ -46,10 +46,11 @@ module Puma
     # elsewhere, i.e. the connection has been hijacked by the Rack application.
     #
     # Finally, it'll return +true+ on keep-alive connections.
+    # @param processor [Puma::ThreadPool::ProcessorThread]
     # @param client [Puma::Client]
     # @param requests [Integer]
     # @return [:close, :keep_alive, :async]
-    def handle_request(client, requests)
+    def handle_request(processor, client, requests)
       env = client.env
       io_buffer = client.io_buffer
       socket  = client.io   # io may be a MiniSSL::Socket
@@ -58,26 +59,6 @@ module Puma
 
       return :close if closed_socket?(socket)
 
-      write_pending_interim socket, client
-
-      if client.http_content_length_limit_exceeded
-        return prepare_response(413, {}, ["Payload Too Large"], requests, client)
-      end
-
-      normalize_env env, client
-
-      env[PUMA_SOCKET] = socket
-
-      if env[HTTPS_KEY] && socket.peercert
-        env[PUMA_PEERCERT] = socket.peercert
-      end
-
-      env[HIJACK_P] = true
-      env[HIJACK] = client.method :full_hijack
-
-      env[RACK_INPUT] = client.body
-      env[RACK_URL_SCHEME] ||= default_server_port(env) == PORT_443 ? HTTPS : HTTP
-
       if @early_hints
         env[EARLY_HINTS] = lambda { |headers|
           begin
@@ -91,22 +72,11 @@ module Puma
         }
       end
 
-      req_env_post_parse env
-
-      # A rack extension. If the app writes #call'ables to this
-      # array, we will invoke them when the request is done.
-      #
-      env[RACK_AFTER_REPLY] ||= []
-      env[RACK_RESPONSE_FINISHED] ||= []
+      env["puma.mark_as_io_bound"] = -> { processor.mark_as_io_thread! }
 
       begin
-        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
-          status, headers, app_body = @thread_pool.with_force_shutdown do
-            @app.call(env)
-          end
-        else
-          @log_writer.log "Unsupported HTTP method used: #{env[REQUEST_METHOD]}"
-          status, headers, app_body = [501, {}, ["#{env[REQUEST_METHOD]} method is not supported"]]
+        status, headers, app_body = @thread_pool.with_force_shutdown do
+          @app.call(env)
         end
 
         # app_body needs to always be closed, hold value in case lowlevel_error
@@ -138,7 +108,6 @@ module Puma
       prepare_response(status, headers, res_body, requests, client)
     ensure
       io_buffer.reset
-      uncork_socket client.io
       app_body.close if app_body.respond_to? :close
       client&.tempfile_close
       if after_reply = env[RACK_AFTER_REPLY]
@@ -179,8 +148,6 @@ module Puma
 
       return :close if closed_socket?(socket)
 
-      write_pending_interim socket, client
-
       # Close the connection after a reasonable number of inline requests
       force_keep_alive = @enable_keep_alives && client.requests_served < @max_keep_alive
 
@@ -249,7 +216,8 @@ module Puma
 
           io_buffer << LINE_END
           fast_write_str socket, io_buffer.read_and_reset
-          socket.flush
+
+          uncork_socket socket.flush
           return keep_alive ? :keep_alive : :close
         end
       else
@@ -268,40 +236,18 @@ module Puma
       # response_hijack.call
       if response_hijack
         fast_write_str socket, io_buffer.read_and_reset
-        uncork_socket socket
+        uncork_socket socket.flush
         response_hijack.call socket
         return :async
       end
 
       fast_write_response socket, body, io_buffer, chunked, content_length.to_i
       body.close if close_body
+
       # if we're shutting down, close keep_alive connections
       !shutting_down? && keep_alive ? :keep_alive : :close
     end
 
-    HTTP_ON_VALUES = { "on" => true, HTTPS => true }
-    private_constant :HTTP_ON_VALUES
-
-    # @param env [Hash] see Puma::Client#env, from request
-    # @return [Puma::Const::PORT_443,Puma::Const::PORT_80]
-    #
-    def default_server_port(env)
-      if HTTP_ON_VALUES[env[HTTPS_KEY]] ||
-          env[HTTP_X_FORWARDED_PROTO]&.start_with?(HTTPS) ||
-          env[HTTP_X_FORWARDED_SCHEME] == HTTPS ||
-          env[HTTP_X_FORWARDED_SSL] == "on"
-        PORT_443
-      else
-        PORT_80
-      end
-    end
-
-    def write_pending_interim(socket, client)
-      pending = client.take_pending_write
-      fast_write_str socket, pending if pending
-    end
-    private :write_pending_interim
-
     # Used to write 'early hints', 'no body' responses, 'hijacked' responses,
     # and body segments (called by `fast_write_response`).
     # Writes a string to a socket (normally `Client#io`) using `write_nonblock`.
@@ -351,11 +297,7 @@ module Puma
             fast_write_str socket, io_buffer.read_and_reset
           else
             fast_write_str socket, io_buffer.read_and_reset
-            remaining = content_length
-            while remaining > 0 && (chunk = body.read([remaining, BODY_LEN_MAX].min))
-              fast_write_str socket, chunk
-              remaining -= chunk.bytesize
-            end
+            IO.copy_stream body, socket
           end
         end
       elsif body.is_a?(::Array) && body.length == 1
@@ -420,6 +362,7 @@ module Puma
         end
       end
       socket.flush
+      uncork_socket socket
     rescue Errno::EAGAIN, Errno::EWOULDBLOCK
       raise ConnectionError, SOCKET_WRITE_ERR_MSG
     rescue  Errno::EPIPE, SystemCallError, IOError
@@ -428,85 +371,6 @@ module Puma
 
     private :fast_write_str, :fast_write_response
 
-    # Given a Hash +env+ for the request read from +client+, add
-    # and fixup keys to comply with Rack's env guidelines.
-    # @param env [Hash] see Puma::Client#env, from request
-    # @param client [Puma::Client] only needed for Client#peerip
-    #
-    def normalize_env(env, client)
-      if host = env[HTTP_HOST]
-        # host can be a hostname, ipv4 or bracketed ipv6. Followed by an optional port.
-        if colon = host.rindex("]:") # IPV6 with port
-          env[SERVER_NAME] = host[0, colon+1]
-          env[SERVER_PORT] = host[colon+2, host.bytesize]
-        elsif !host.start_with?("[") && colon = host.index(":") # not hostname or IPV4 with port
-          env[SERVER_NAME] = host[0, colon]
-          env[SERVER_PORT] = host[colon+1, host.bytesize]
-        else
-          env[SERVER_NAME] = host
-          env[SERVER_PORT] = default_server_port(env)
-        end
-      else
-        env[SERVER_NAME] = LOCALHOST
-        env[SERVER_PORT] = default_server_port(env)
-      end
-
-      unless env[REQUEST_PATH]
-        # it might be a dumbass full host request header
-        uri = begin
-          URI.parse(env[REQUEST_URI])
-        rescue URI::InvalidURIError
-          raise Puma::HttpParserError
-        end
-        env[REQUEST_PATH] = uri.path
-
-        # A nil env value will cause a LintError (and fatal errors elsewhere),
-        # so only set the env value if there actually is a value.
-        env[QUERY_STRING] = uri.query if uri.query
-      end
-
-      env[PATH_INFO] = env[REQUEST_PATH].to_s # #to_s in case it's nil
-
-      # From https://www.ietf.org/rfc/rfc3875 :
-      # "Script authors should be aware that the REMOTE_ADDR and
-      # REMOTE_HOST meta-variables (see sections 4.1.8 and 4.1.9)
-      # may not identify the ultimate source of the request.
-      # They identify the client for the immediate request to the
-      # server; that client may be a proxy, gateway, or other
-      # intermediary acting on behalf of the actual source client."
-      #
-
-      unless env.key?(REMOTE_ADDR)
-        begin
-          addr = client.peerip
-        rescue Errno::ENOTCONN
-          # Client disconnects can result in an inability to get the
-          # peeraddr from the socket; default to unspec.
-          if client.peer_family == Socket::AF_INET6
-            addr = UNSPECIFIED_IPV6
-          else
-            addr = UNSPECIFIED_IPV4
-          end
-        end
-
-        # Set unix socket addrs to localhost
-        if addr.empty?
-          if client.peer_family == Socket::AF_INET6
-            addr = LOCALHOST_IPV6
-          else
-            addr = LOCALHOST_IPV4
-          end
-        end
-
-        env[REMOTE_ADDR] = addr
-      end
-
-      # The legacy HTTP_VERSION header can be sent as a client header.
-      # Rack v4 may remove using HTTP_VERSION.  If so, remove this line.
-      env[HTTP_VERSION] = env[SERVER_PROTOCOL] if @env_set_http_version
-    end
-    private :normalize_env
-
     # @param header_key [#to_s]
     # @return [Boolean]
     #
@@ -520,56 +384,6 @@ module Puma
     def illegal_header_value?(header_value)
       !!(ILLEGAL_HEADER_VALUE_REGEX =~ header_value.to_s)
     end
-    private :illegal_header_key?, :illegal_header_value?
-
-    # Fixup any headers with `,` in the name to have `_` now. We emit
-    # headers with `,` in them during the parse phase to avoid ambiguity
-    # with the `-` to `_` conversion for critical headers. But here for
-    # compatibility, we'll convert them back. This code is written to
-    # avoid allocation in the common case (ie there are no headers
-    # with `,` in their names), that's why it has the extra conditionals.
-    #
-    # @note If a normalized version of a `,` header already exists, we ignore
-    #       the `,` version. This prevents clobbering headers managed by proxies
-    #       but not by clients (Like X-Forwarded-For).
-    #
-    # @param env [Hash] see Puma::Client#env, from request, modifies in place
-    # @version 5.0.3
-    #
-    def req_env_post_parse(env)
-      to_delete = nil
-      to_add = nil
-
-      env.each do |k,v|
-        if k.start_with?("HTTP_") && k.include?(",") && !UNMASKABLE_HEADERS.key?(k)
-          if to_delete
-            to_delete << k
-          else
-            to_delete = [k]
-          end
-
-          new_k = k.tr(",", "_")
-          if env.key?(new_k)
-            next
-          end
-
-          unless to_add
-            to_add = {}
-          end
-
-          to_add[new_k] = v
-        end
-      end
-
-      if to_delete # rubocop:disable Style/SafeNavigation
-        to_delete.each { |k| env.delete(k) }
-      end
-
-      if to_add
-        env.merge! to_add
-      end
-    end
-    private :req_env_post_parse
 
     # Used in the lambda for env[ `Puma::Const::EARLY_HINTS` ]
     # @param headers [Hash] the headers returned by the Rack application
@@ -666,7 +480,8 @@ module Puma
       headers.each do |k, vs|
         next if illegal_header_key?(k)
 
-        case k.downcase
+        key = k.downcase
+        case key
         when CONTENT_LENGTH2
           next if illegal_header_value?(vs)
           # nil.to_i is 0, nil&.to_i is nil
@@ -693,10 +508,10 @@ module Puma
         if ary
           ary.each do |v|
             next if illegal_header_value?(v)
-            io_buffer.append k.downcase, colon, v, line_ending
+            io_buffer.append key, colon, v, line_ending
           end
         else
-          io_buffer.append k.downcase, colon, line_ending
+          io_buffer.append key, colon, line_ending
         end
       end