WIP

Author: ioquatix

lib/protocol/http1/body/upgrade.md

@@ -0,0 +1,22 @@
+# Upgrade
+
+Connection upgrade in HTTP/1 is considered an intermediate response, yet it should be considered a final response as no further HTTP/1 messages are expected. The upgrade response is a signal to the client that the server is switching to a different protocol. The client should switch to the new protocol immediately.
+
+```ruby
+connection = Protocol::HTTP1::Connection.new(peer)
+
+while stream = connection.accept_stream
+	stream.
+
+
+body = Protocol::HTTP::Body::Writable.new
+request = Protocol::HTTP::Request.new("wss", "websockets.local", "GET", "/chat", nil, Protocol::HTTP::Headers.new, body, ["websocket"])
+connection.write_request(request)
+
+while response = connection.read_response
+	break if response.final?
+
+	if response.status == 101
+		
+		break
+	end

lib/protocol/http1/body/upgrade.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2019-2024, by Samuel Williams.
+
+require 'protocol/http/body/readable'
+
+module Protocol
+	module HTTP1
+		module Body
+			class Upgrade < HTTP::Body::Readable
+				BLOCK_SIZE = 1024 * 64
+				
+				class Trigger
+					def initialize
+						@queue = ::Thread::Queue.new
+					end
+					
+					def wait
+						if queue = @queue
+							queue.pop
+						end
+						
+						return true
+					end
+					
+					def signal
+						if @queue
+							@queue.close
+							@queue = nil
+						end
+					end
+				end
+				
+				# block_size may be removed in the future. It is better managed by stream.
+				def initialize(stream)
+					@stream = stream
+					@upgraded = false
+					
+					@ready = Trigger.new
+					@remainder = nil
+				end
+				
+				def upgrade!
+					@upgraded = true
+					@ready.signal
+				end
+				
+				def empty?
+					if @remainder
+						@remainder.empty?
+					else
+						false # Unknown.
+					end
+				end
+				
+				def close(error = nil)
+					if @remainder
+						@remainder.close(error)
+					else
+						@stream = nil
+					end
+				end
+				
+				# TODO this is a bit less efficient in order to maintain compatibility with `IO`.
+				def read
+					@ready.wait
+					
+					return @remainder.read
+				end
+				
+				def call(stream)
+					@ready.wait
+					
+					@remainder.read
+				end
+				
+				def join
+					@ready.wait
+					
+					@remainder.join
+				end
+				
+				def inspect
+					"\#<#{self.class} #{@ready ? }>"
+				end
+			end
+		end
+	end
+end

lib/protocol/http1/connection.rb

@@ -55,6 +55,8 @@ def initialize(stream, persistent = true)
 
 				@persistent = persistent
 
+				@upgrade_body = nil
+				
 				@count = 0
 			end
 
@@ -435,6 +437,10 @@ def read_tunnel_body
 				read_remainder_body
 			end
 
+			def read_upgrade_body
+				@upgrade_body = Body::Upgrade.new(@stream)
+			end
+			
 			HEAD = "HEAD"
 			CONNECT = "CONNECT"
 
@@ -505,7 +511,7 @@ def read_request_body(method, headers)
 
 				# A successful upgrade response implies that the connection will become a tunnel immediately after the empty line that concludes the header fields.
 				if headers[UPGRADE]
-					return read_tunnel_body
+					return read_upgrade_body
 				end
 
 				# 6.  If this is a request message and none of the above are true, then