`class Connection`

An HTTP/1 connection that wraps an IO stream with version and state tracking.

Definitions

`def initialize(stream, version, **options)`

Initialize the connection with an IO stream and HTTP version.

Signature

parameter　stream　IO::Stream: The underlying stream.
parameter　version　String: The negotiated HTTP version string.
parameter　options　Hash: Additional options for the connection.

Implementation

def initialize(stream, version, **options)
	super(stream, **options)
	
	# On the client side, we need to send the HTTP version with the initial request. On the server side, there are some scenarios (bad request) where we don't know the request version. In those cases, we use this value, which is either hard coded based on the protocol being used, OR could be negotiated during the connection setup (e.g. ALPN).
	@version = version
end

`def to_s`

Signature

returns　String: A string representation of this connection.

Implementation

def to_s
	"\#<#{self.class} negotiated #{@version}, #{@state}>"
end

`def as_json(...)`

Signature

returns　String: A JSON-compatible representation.

Implementation

def as_json(...)
	to_s
end

`def to_json(...)`

Signature

returns　String: A JSON string representation.

Implementation

def to_json(...)
	as_json.to_json(...)
end

`def http1?`

Signature

returns　Boolean: Whether this is an HTTP/1 connection.

Implementation

def http1?
	true
end

`def http2?`

Signature

returns　Boolean: Whether this is an HTTP/2 connection.

Implementation

def http2?
	false
end

`def peer`

Signature

returns　Protocol::HTTP::Peer: The peer information for this connection.

Implementation

def peer
	@peer ||= ::Protocol::HTTP::Peer.for(@stream.io)
end

`def concurrency`

Signature

returns　Integer: The maximum number of concurrent requests (always 1 for HTTP/1).

Implementation

def concurrency
	1
end

`def viable?`

Can we use this connection to make requests?

Implementation

def viable?
	unless self.idle?
		return false
	end
	
	unless @stream
		return false
	end
	
	# `nil` indicates that the connection has no data, but is still alive. An empty string means the connection is closed, while a non-empty string indicates application data on a idle HTTP/1 connection, both are failure cases.
	if @stream.peek_partial(1)
		return false
	end
	
	return @stream.readable?
rescue => error
	Console.debug(self, "Connection viability probe failed!", exception: error)
	
	return false
end

`def reusable?`

Signature

returns　Boolean: Whether the connection can be reused for another request.

Implementation

def reusable?
	@persistent && @stream && !@stream.closed?
end