http3 0.0.4 → 0.0.5

data/lib/http3/body_stream.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module HTTP3
+  module Body
+    # The stream a streaming body (Rack 3's call(stream)) is called with.
+    # What it writes goes to a Body::Pipe, and what it reads comes from the
+    # request body, which has arrived in full. Its methods behave as IO's
+    # do, as Rack 3 asks: write takes any objects and returns the bytes
+    # written, a write or flush after close_write raises IOError, as a read
+    # after close_read does, and the closes may be called again.
+    #
+    # Once the stream has gone away (the client reset it or sent
+    # STOP_SENDING, or it was aborted after response_timeout), write and
+    # flush raise StreamClosed, and so do close_write and close, once.
+    # Writing past length, the content-length, fails the pipe, so that the
+    # stream is aborted, and raises StreamClosed, so that the body stops
+    # there; ending short of it fails the pipe too.
+    class Stream
+      def initialize(pipe:, input:, length:)
+        @pipe = pipe
+        @input = input
+        @length = length
+        @size = 0
+        @failed = false
+        @read_closed = false
+        @write_closed = false
+        @lock = Thread::Mutex.new
+      end
+
+      # Read from the request body, as IO#read does.
+      def read(...)
+        raise IOError, "not opened for reading" if @read_closed
+
+        @input.read(...)
+      end
+
+      # Write each of objects, as a String (to_s), first waiting while the
+      # pipe is full. Returns the bytes written.
+      def write(*objects)
+        @lock.synchronize do
+          objects.sum do |object|
+            chunk = object.to_s
+            check_writable
+            count(chunk.bytesize)
+            @pipe.write(chunk)
+          end
+        end
+      end
+
+      def <<(object)
+        write(object)
+        self
+      end
+
+      # Wait until what has been written has been taken to be sent.
+      def flush
+        @lock.synchronize { check_writable }
+        @pipe.flush
+        self
+      end
+
+      # Stop reading: close the request body, unless it is closed already.
+      def close_read
+        @read_closed = true
+        @input.close unless @input.closed?
+        nil
+      end
+
+      # End the body, and wait until all of it has been taken to be sent;
+      # fail the pipe instead if it is short of length.
+      def close_write
+        @lock.synchronize do
+          next if @write_closed
+
+          @write_closed = true
+          next if @failed
+
+          if @length && @size != @length
+            @pipe.fail(length_mismatch("the body is #{@size} bytes"))
+          else
+            @pipe.finish
+          end
+        end
+        nil
+      end
+
+      def close
+        close_read
+        close_write
+      end
+
+      def closed?
+        @read_closed && @write_closed
+      end
+
+      private
+
+      # With the lock held.
+      def check_writable
+        raise IOError, "not opened for writing" if @write_closed
+        raise StreamClosed, "stream closed" if @failed
+      end
+
+      # With the lock held. Past length, the pipe fails and StreamClosed is
+      # raised.
+      def count(bytes)
+        @size += bytes
+        return unless @length && @size > @length
+
+        @failed = true
+        @pipe.fail(length_mismatch("the body is at least #{@size} bytes"))
+        raise StreamClosed, "stream closed"
+      end
+
+      def length_mismatch(what)
+        RackAdapter::InvalidResponse.new("#{what} but content-length says otherwise")
+      end
+    end
+  end
+end

data/lib/http3/rack_adapter.rb

@@ -5,7 +5,8 @@ require "uri"
 
 module HTTP3
   # Calls a Rack 3 application for an HTTP3::Request and turns what it
-  # returns into an HTTP3::Response.
+  # returns into an HTTP3::Response. Several threads may call it at once,
+  # each for a request of its own.
   class RackAdapter
     # The application's response breaks the Rack 3 specification; the
     # server answers 500 instead.
@@ -34,27 +35,41 @@ module HTTP3
     # specification).
     FORBIDDEN_IN_VALUE = /[\0\r\n]/
 
-    def initialize(app)
+    # A body read with each, and a streaming body, go through a Body::Pipe
+    # of pipe_capacity bytes, whose wake is wake.
+    def initialize(app, pipe_capacity:, wake:)
       @app = app
+      @pipe_capacity = pipe_capacity
+      @wake = wake
       @refusals = Hash.new(0)
+      @refusals_lock = Thread::Mutex.new
     end
 
-    # remote is the client's address, an Addrinfo. CONNECT is answered with
-    # 501, and a request the Rack env cannot carry with 400, without calling
-    # the application; #take_refusals counts them. Raises whatever the
-    # application raises, and InvalidResponse for a response that cannot be
-    # sent; the Rack body is closed in both cases.
+    # Returns [response, fill]. remote is the client's address, an
+    # Addrinfo. CONNECT is answered with 501, and a request the Rack env
+    # cannot carry with 400, without calling the application;
+    # #take_refusals counts them. Raises whatever the application raises,
+    # and InvalidResponse for a response that cannot be sent; the Rack body
+    # is closed in both cases.
+    #
+    # fill is nil, the Rack body closed already, unless the response sends
+    # a body that is read with each or is a streaming body (call): its
+    # response has a Body::Pipe, and fill, called once the response has
+    # been handed over, writes the body to it and closes the Rack body.
+    # fill returns nil, or an exception the body raised that did not abort
+    # its stream, the body having ended or the server having given up on
+    # it, for the caller to log.
     def call(request, remote:)
       # The server cannot open a tunnel (RFC 9114 section 4.4), and a
       # CONNECT request has neither :scheme nor :path, so the env would be
       # made up. The Session leaves nghttp3's enable_connect_protocol off,
       # so nghttp3 refuses the :protocol of an extended CONNECT (RFC 9220).
-      return refuse(501) if request.headers.assoc(":method")&.last == "CONNECT"
+      return [refuse(501), nil] if request.headers.assoc(":method")&.last == "CONNECT"
 
       env = env_for(request, remote)
     rescue BadRequest
       # Not logged: the client sent it, the server did not fail.
-      refuse(400)
+      [refuse(400), nil]
     else
       status, headers, body = @app.call(env)
       response_for(request, status, headers, body)
@@ -63,15 +78,17 @@ module HTTP3
     # The requests answered without the application since the last call,
     # as {status => count}; the count starts over.
     def take_refusals
-      refusals = @refusals
-      @refusals = Hash.new(0)
-      refusals
+      @refusals_lock.synchronize do
+        refusals = @refusals
+        @refusals = Hash.new(0)
+        refusals
+      end
     end
 
     private
 
     def refuse(status)
-      @refusals[status] += 1
+      @refusals_lock.synchronize { @refusals[status] += 1 }
       Response.new(status: status, headers: [], body: nil)
     end
 
@@ -125,7 +142,7 @@ module HTTP3
         "REMOTE_ADDR" => remote.ip_address,
         "HTTP_HOST" => authority,
         "rack.url_scheme" => scheme,
-        "rack.input" => StringIO.new(request.body.b),
+        "rack.input" => request.input,
         "rack.errors" => $stderr
       }
       fields.each do |name, values|
@@ -151,10 +168,12 @@ module HTTP3
       end
     end
 
-    # The Rack body is closed here unless it goes on in the Response, or
-    # to_ary has closed it (body_for yields then).
+    # [response, fill]. The Rack body is closed here, before anything is
+    # sent, unless fill goes on with it, or to_ary has closed it (body_for
+    # yields then). Rack 3 only says it is closed "typically after" the
+    # body has been sent, and the Body::File reads the file through a
+    # descriptor of its own.
     def response_for(request, status, headers, body)
-      response = nil
       status = Integer(status)
       # A 1xx is no final response, which is all HTTP/3 can send here (Rack
       # Lint only asks for 100 or more).
@@ -168,15 +187,21 @@ module HTTP3
       length = content_length(headers)
 
       method = request.headers.assoc(":method")&.last
-      response = if method == "HEAD" || status == 204 || status == 304
+      if method == "HEAD" || status == 204 || status == 304
         # No body is sent, so content-length is not held against one.
-        close_rack_body(body)
-        Response.new(status: status, headers: headers, body: nil)
-      else
-        Response.new(status: status, headers: headers, body: body_for(body, length) { body = nil })
+        return [Response.new(status: status, headers: headers, body: nil), nil]
       end
+
+      sent, fill = body_for(body, length, request.input) { body = nil }
+      [Response.new(status: status, headers: headers, body: sent), fill]
     ensure
-      close_rack_body(body) if response.nil?
+      begin
+        close_rack_body(body)
+      rescue
+        # The response goes nowhere: a 500 replaces it.
+        sent.io.close if sent.is_a?(Body::File)
+        raise
+      end
     end
 
     # The content-length among headers, as an Integer, or nil if there is
@@ -214,10 +239,12 @@ module HTTP3
       pairs
     end
 
-    # The body to send. One whose length is known before it is sent, a file
-    # or an Array, is held against length, the content-length, now; one
-    # read with each, as it is read (#counted).
-    def body_for(body, length)
+    # [the body to send, fill]. One whose length is known before it is
+    # sent, a file or an Array, is held against length, the content-length,
+    # now; one read with each, and a streaming body, as fill writes it. A
+    # streaming body reads input, the request body. body_for yields when
+    # the Rack body is no longer for response_for to close.
+    def body_for(body, length, input)
       if body.respond_to?(:to_path)
         io = ::File.open(body.to_path, "rb")
         if length && io.size != length
@@ -225,7 +252,7 @@ module HTTP3
           io.close
           raise length_mismatch(size)
         end
-        Body::File.new(io: io, offset: 0, length: io.size, rack_body: body)
+        [Body::File.new(io: io, offset: 0, length: io.size, rack_body: nil), nil]
       elsif body.respond_to?(:to_ary)
         # Rack 3 has to_ary close the body itself.
         chunks = body.to_ary
@@ -238,32 +265,72 @@ module HTTP3
         size = chunks.sum(&:bytesize)
         raise length_mismatch(size) if length && size != length
 
-        Body::Chunks.new(enum: chunks.each, rack_body: nil)
+        [Body::Chunks.new(enum: chunks.each, rack_body: nil), nil]
       elsif body.respond_to?(:each)
-        enum = length ? counted(body, length) : body.to_enum(:each)
-        Body::Chunks.new(enum: enum, rack_body: body)
+        # Rack 3: a body with both each and call is read with each.
+        pipe = Body::Pipe.new(capacity: @pipe_capacity, wake: @wake)
+        yield
+        [pipe, -> { fill_each(body, pipe, length) }]
+      elsif body.respond_to?(:call)
+        pipe = Body::Pipe.new(capacity: @pipe_capacity, wake: @wake)
+        yield
+        [pipe, -> { fill_call(body, pipe, length, input) }]
       else
-        raise InvalidResponse, "streaming bodies (#{body.class}) are not supported"
+        raise InvalidResponse, "the body (#{body.class}) responds to neither each nor call"
       end
     end
 
-    # The chunks of body's each, raising InvalidResponse from next once they
-    # pass length bytes, or end short of it. Session#fill_bodies aborts the
-    # stream then, since the headers have gone. A chunk that is not a String
-    # goes on to fill_bodies, which refuses it.
-    def counted(body, length)
-      Enumerator.new do |y|
-        size = 0
-        body.each do |chunk|
-          size += chunk.bytesize if chunk.is_a?(String)
-          if size > length
-            raise InvalidResponse, "the body is at least #{size} bytes but content-length says otherwise"
-          end
-
-          y << chunk
+    # Write the chunks of body's each to pipe, and end it. A chunk that is
+    # not a String, one that takes the body past length bytes, an end short
+    # of it, and an exception from each fail the pipe, and the stream is
+    # aborted then, since the headers have gone. A pipe the server has given
+    # up on (the client reset the stream, say) makes write raise
+    # StreamClosed, and the body stops there, without failing. Returns an
+    # exception the pipe did not take, or nil. The Rack body is closed in
+    # every case; an exception from its close is raised.
+    def fill_each(body, pipe, length)
+      size = 0
+      body.each do |chunk|
+        raise InvalidResponse, "body chunk must be a String (got #{chunk.class})" unless chunk.is_a?(String)
+
+        size += chunk.bytesize
+        if length && size > length
+          raise InvalidResponse, "the body is at least #{size} bytes but content-length says otherwise"
         end
-        raise length_mismatch(size) if size < length
+
+        pipe.write(chunk)
       end
+      raise length_mismatch(size) if length && size < length
+
+      pipe.finish
+    rescue StreamClosed
+      nil
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      # Even exit, on a worker, ends only the body.
+      e unless pipe.fail(e)
+    ensure
+      close_rack_body(body)
+    end
+
+    # Call the streaming body with a Body::Stream that writes to pipe and
+    # reads input, and end the body once call returns, unless it has ended
+    # already: a write after that, from another thread, raises IOError. As
+    # with fill_each, the stream is aborted once the body goes past length
+    # bytes or ends short of it, or call raises, and it stops without
+    # failing once the server has given up on the pipe. Returns an
+    # exception the pipe did not take, such as one call raised after it
+    # closed the stream, or nil. The Rack body is closed in every case; an
+    # exception from its close is raised.
+    def fill_call(body, pipe, length, input)
+      stream = Body::Stream.new(pipe: pipe, input: input, length: length)
+      body.call(stream)
+      stream.close_write
+    rescue StreamClosed
+      nil
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      e unless pipe.fail(e)
+    ensure
+      close_rack_body(body)
     end
 
     def length_mismatch(size)

data/lib/http3/request.rb

@@ -4,6 +4,8 @@ module HTTP3
   # A request as a Session put it together. headers is an Array of
   # [name, value] binary Strings with lowercase names, the pseudo-headers
   # (:method, :scheme, :authority, :path) first; a repeated name keeps one
-  # pair per field. body is the request body, a binary String.
-  Request = Data.define(:stream_id, :headers, :body)
+  # pair per field. input is the request body, a binary IO at its start,
+  # which becomes rack.input: a StringIO, or a temporary File once the body
+  # is past the Session's request_body_buffer_size.
+  Request = Data.define(:stream_id, :headers, :input)
 end