module Protocol::HTTP2::FlowControlled

Public Instance Methods

available_frame_size(maximum_frame_size = self.maximum_frame_size) click to toggle source

This could be negative if the window has been overused due to a change in initial window size.

# File lib/protocol/http2/flow_controlled.rb, line 31
def available_frame_size(maximum_frame_size = self.maximum_frame_size)
        available_size = self.available_size
        
        # puts "available_size=#{available_size} maximum_frame_size=#{maximum_frame_size}"
        
        if available_size < maximum_frame_size
                return available_size
        else
                return maximum_frame_size
        end
end
available_size() click to toggle source
# File lib/protocol/http2/flow_controlled.rb, line 26
def available_size
        @remote_window.available
end
consume_local_window(frame) click to toggle source
# File lib/protocol/http2/flow_controlled.rb, line 62
def consume_local_window(frame)
        # For flow-control calculations, the 9-octet frame header is not counted.
        amount = frame.length
        @local_window.consume(amount)
end
consume_remote_window(frame) click to toggle source

Keep track of the amount of data sent, and fail if is too much.

# File lib/protocol/http2/flow_controlled.rb, line 44
def consume_remote_window(frame)
        amount = frame.length
        
        # Frames with zero length with the END_STREAM flag set (that is, an empty DATA frame) MAY be sent if there is no available space in either flow-control window.
        if amount.zero? and frame.end_stream?
                # It's okay, we can send. No need to consume, it's empty anyway.
        elsif amount >= 0 and amount <= @remote_window.available
                @remote_window.consume(amount)
        else
                raise FlowControlError, "Trying to send #{frame.length} bytes, exceeded window size: #{@remote_window.available} (#{@remote_window})"
        end
end
receive_window_update(frame) click to toggle source
# File lib/protocol/http2/flow_controlled.rb, line 84
def receive_window_update(frame)
        amount = frame.unpack
        
        # Async.logger.info(self) {"expanding remote_window=#{@remote_window} by #{amount}"}
        
        if amount != 0
                @remote_window.expand(amount)
        else
                raise ProtocolError, "Invalid window size increment: #{amount}!"
        end
        
        # puts "expanded remote_window=#{@remote_window} by #{amount}"
end
request_window_update() click to toggle source
# File lib/protocol/http2/flow_controlled.rb, line 68
def request_window_update
        if @local_window.limited?
                self.send_window_update(@local_window.wanted)
        end
end
send_window_update(window_increment) click to toggle source

Notify the remote end that we are prepared to receive more data:

# File lib/protocol/http2/flow_controlled.rb, line 75
def send_window_update(window_increment)
        frame = WindowUpdateFrame.new(self.id)
        frame.pack window_increment
        
        write_frame(frame)
        
        @local_window.expand(window_increment)
end
update_local_window(frame) click to toggle source
# File lib/protocol/http2/flow_controlled.rb, line 57
def update_local_window(frame)
        consume_local_window(frame)
        request_window_update
end
window_updated(size) click to toggle source

The window has been expanded by the given amount. @param size [Integer] the maximum amount of data to send. @return [Boolean] whether the window update was used or not.

# File lib/protocol/http2/flow_controlled.rb, line 101
def window_updated(size)
        return false
end