class Stream

parameter　connection　Connection

The connection this stream belongs to.

parameter　id　Integer

The stream identifier.

returns　Stream

The newly created stream.

def self.create(connection, id)
	stream = self.new(connection, id)
	
	connection.streams[id] = stream
	
	return stream
end

parameter　connection　Connection

The connection this stream belongs to.

parameter　id　Integer

The stream identifier.

parameter　state　Symbol

The initial stream state.

def initialize(connection, id, state = :idle)
	@connection = connection
	@id = id
	
	@state = state
	
	@local_window = Window.new(@connection.local_settings.initial_window_size)
	@remote_window = Window.new(@connection.remote_settings.initial_window_size)
	
	@priority = nil
end

attribute　Protocol::HTTP::Header::Priority | Nil

the priority of the stream.

returns　Integer

The maximum frame size from connection settings.

def maximum_frame_size
	@connection.available_frame_size
end

parameter　frame　Frame

The frame to write.

def write_frame(frame)
	@connection.write_frame(frame)
end

returns　Boolean

True if the stream is active.

def active?
	@state != :closed && @state != :idle
end

returns　Boolean

True if the stream is in closed state.

def closed?
	@state == :closed
end

def close(error = nil)
	unless closed?
		@state = :closed
		self.closed(error)
	end
end

def send_headers?
	@state == :idle or @state == :reserved_local or @state == :open or @state == :half_closed_remote
end

def send_headers(*arguments)
	if @state == :idle
		frame = write_headers(*arguments)
		
		if frame.end_stream?
			@state = :half_closed_local
		else
			open!
		end
	elsif @state == :reserved_local
		frame = write_headers(*arguments)
		
		@state = :half_closed_remote
	elsif @state == :open
		frame = write_headers(*arguments)
		
		if frame.end_stream?
			@state = :half_closed_local
		end
	elsif @state == :half_closed_remote
		frame = write_headers(*arguments)
		
		if frame.end_stream?
			close!
		end
	else
		raise ProtocolError, "Cannot send headers in state: #{@state}"
	end
end

parameter　frame　Frame

The frame that consumes window space.

def consume_remote_window(frame)
	super
	
	@connection.consume_remote_window(frame)
end

parameter　arguments　Array

Arguments passed to write_data.

parameter　options　Hash

Options passed to write_data.

def send_data(*arguments, **options)
	if @state == :open
		frame = write_data(*arguments, **options)
		
		if frame.end_stream?
			@state = :half_closed_local
		end
	elsif @state == :half_closed_remote
		frame = write_data(*arguments, **options)
		
		if frame.end_stream?
			close!
		end
	else
		raise ProtocolError, "Cannot send data in state: #{@state}"
	end
end

returns　Stream

Returns self for chaining.

raises　ProtocolError

If the stream cannot be opened from current state.

def open!
	if @state == :idle
		@state = :open
	else
		raise ProtocolError, "Cannot open stream in state: #{@state}"
	end
	
	return self
end

def closed(error = nil)
end

parameter　error_code　Integer

the error code if the stream was closed due to a stream reset.

def close!(error_code = nil)
	@state = :closed
	@connection.delete(@id)
	
	if error_code
		error = StreamError.new("Stream closed!", error_code)
	end
	
	self.closed(error)
	
	return self
end

parameter　error_code　Integer

The error code to send.

def send_reset_stream(error_code = 0)
	if @state != :idle and @state != :closed
		frame = ResetStreamFrame.new(@id)
		frame.pack(error_code)
		
		write_frame(frame)
		
		close!
	else
		raise ProtocolError, "Cannot send reset stream (#{error_code}) in state: #{@state}"
	end
end

parameter　frame　HeadersFrame

The headers frame to process.

returns　Array

The decoded headers.

def process_headers(frame)
	# Receiving request headers:
	data = frame.unpack
	
	@connection.decode_headers(data)
end

parameter　frame　HeadersFrame

The headers frame to receive.

def receive_headers(frame)
	if @state == :idle
		if frame.end_stream?
			@state = :half_closed_remote
		else
			open!
		end
		
		process_headers(frame)
	elsif @state == :reserved_remote
		process_headers(frame)
		
		@state = :half_closed_local
	elsif @state == :open
		process_headers(frame)
		
		if frame.end_stream?
			@state = :half_closed_remote
		end
	elsif @state == :half_closed_local
		process_headers(frame)
		
		if frame.end_stream?
			close!
		end
	elsif self.closed?
		ignore_headers(frame)
	else
		self.send_reset_stream(Error::STREAM_CLOSED)
	end
end

def process_data(frame)
	frame.unpack
end

parameter　frame　DataFrame

The data frame to ignore.

def ignore_data(frame)
	# Console.warn(self) {"Received headers in state: #{@state}!"}
end

def receive_data(frame)
	if @state == :open
		update_local_window(frame)
		
		if frame.end_stream?
			@state = :half_closed_remote
		end
		
		process_data(frame)
	elsif @state == :half_closed_local
		update_local_window(frame)
		
		process_data(frame)
		
		if frame.end_stream?
			close!
		end
	elsif self.closed?
		ignore_data(frame)
	else
		# If a DATA frame is received whose stream is not in "open" or "half-closed (local)" state, the recipient MUST respond with a stream error (Section 5.4.2) of type STREAM_CLOSED.
		self.send_reset_stream(Error::STREAM_CLOSED)
	end
end

parameter　frame　ResetStreamFrame

The reset stream frame to receive.

returns　Integer

The error code from the reset frame.

raises　ProtocolError

If reset is received on an idle stream.

def receive_reset_stream(frame)
	if @state == :idle
		# If a RST_STREAM frame identifying an idle stream is received, the recipient MUST treat this as a connection error (Section 5.4.1) of type PROTOCOL_ERROR.
		raise ProtocolError, "Cannot receive reset stream in state: #{@state}!"
	else
		error_code = frame.unpack
		
		close!(error_code)
		
		return error_code
	end
end

returns　Stream

Returns self for chaining.

raises　ProtocolError

If the stream cannot be reserved from current state.

def reserved_local!
	if @state == :idle
		@state = :reserved_local
	else
		raise ProtocolError, "Cannot reserve stream in state: #{@state}"
	end
	
	return self
end

returns　Stream

Returns self for chaining.

raises　ProtocolError

If the stream cannot be reserved from current state.

def reserved_remote!
	if @state == :idle
		@state = :reserved_remote
	else
		raise ProtocolError, "Cannot reserve stream in state: #{@state}"
	end
	
	return self
end

def create_push_promise_stream(headers)
	@connection.create_push_promise_stream
end

parameter　headers　Hash

contains a complete set of request header fields that the server attributes to the request.

def send_push_promise(headers)
	if @state == :open or @state == :half_closed_remote
		promised_stream = self.create_push_promise_stream(headers)
		promised_stream.reserved_local!
		
		# The headers are the same as if the client had sent a request:
		write_push_promise(promised_stream.id, headers)
		
		# The server should call send_headers on the promised stream to begin sending the response:
		return promised_stream
	else
		raise ProtocolError, "Cannot send push promise in state: #{@state}"
	end
end

def accept_push_promise_stream(stream_id, headers)
	@connection.accept_push_promise_stream(stream_id)
end

parameter　frame　PushPromiseFrame

The push promise frame to receive.

def receive_push_promise(frame)
	promised_stream_id, data = frame.unpack
	headers = @connection.decode_headers(data)
	
	stream = self.accept_push_promise_stream(promised_stream_id, headers)
	stream.reserved_remote!
	
	return stream, headers
end

returns　String

Human-readable stream information.

def inspect
	"\#<#{self.class} id=#{@id} state=#{@state}>"
end