Class: HTTP2::Connection

Inherits:
Object
  • Object
show all
Includes:
Emitter, Error, FlowBuffer
Defined in:
lib/http/2/connection.rb

Overview

Connection encapsulates all of the connection, stream, flow-control, error management, and other processing logic required for a well-behaved HTTP 2.0 endpoint.

Note that this class should not be used directly. Instead, you want to use either Client or Server class to drive the HTTP 2.0 exchange.

Direct Known Subclasses

Client, Server

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Emitter

#add_listener, #emit, #once

Methods included from FlowBuffer

#buffered_amount

Constructor Details

#initialize(**settings) ⇒ Connection

Initializes new connection object.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/http/2/connection.rb', line 74

def initialize(**settings)
  @local_settings  = DEFAULT_CONNECTION_SETTINGS.merge(settings)
  @remote_settings = SPEC_DEFAULT_CONNECTION_SETTINGS.dup

  @compressor   = Header::Compressor.new(settings)
  @decompressor = Header::Decompressor.new(settings)

  @active_stream_count = 0
  @streams = {}
  @pending_settings = []

  @framer = Framer.new

  @local_window_limit = @local_settings[:settings_initial_window_size]
  @local_window = @local_window_limit
  @remote_window_limit = @remote_settings[:settings_initial_window_size]
  @remote_window = @remote_window_limit

  @recv_buffer = Buffer.new
  @send_buffer = []
  @continuation = []
  @error = nil
end

Instance Attribute Details

#active_stream_count ⇒ Object (readonly)

Number of active streams between client and server (reserved streams are not counted towards the stream limit).



70
71
72
 
# File 'lib/http/2/connection.rb', line 70

def active_stream_count
  @active_stream_count
end

#error ⇒ Object (readonly)

Last connection error if connection is aborted.



52
53
54
 
# File 'lib/http/2/connection.rb', line 52

def error
  @error
end

#local_settings ⇒ Object (readonly)

Current settings value for local and peer



61
62
63
 
# File 'lib/http/2/connection.rb', line 61

def local_settings
  @local_settings
end

#local_window ⇒ Object (readonly) Also known as: window

Size of current connection flow control window (by default, set to infinity, but is automatically updated on receipt of peer settings).



56
57
58
 
# File 'lib/http/2/connection.rb', line 56

def local_window
  @local_window
end

#pending_settings ⇒ Object (readonly)

Pending settings value

Sent but not ack'ed settings



66
67
68
 
# File 'lib/http/2/connection.rb', line 66

def pending_settings
  @pending_settings
end

#remote_settings ⇒ Object (readonly)

Returns the value of attribute remote_settings.



62
63
64
 
# File 'lib/http/2/connection.rb', line 62

def remote_settings
  @remote_settings
end

#remote_window ⇒ Object (readonly)

Returns the value of attribute remote_window.



57
58
59
 
# File 'lib/http/2/connection.rb', line 57

def remote_window
  @remote_window
end

#state ⇒ Object (readonly)

Connection state (:new, :closed).



49
50
51
 
# File 'lib/http/2/connection.rb', line 49

def state
  @state
end

Instance Method Details

#goaway(error = :no_error, payload = nil) ⇒ Object

Sends a GOAWAY frame indicating that the peer should stop creating new streams for current connection.

Endpoints MAY append opaque data to the payload of any GOAWAY frame. Additional debug data is intended for diagnostic purposes only and carries no semantic value. Debug data MUST NOT be persistently stored, since it could contain sensitive information.

Parameters:

  • error (Symbol) (defaults to: :no_error)
  • payload (String) (defaults to: nil) 


132
133
134
135
136
137
138
 
# File 'lib/http/2/connection.rb', line 132

def goaway(error = :no_error, payload = nil)
  send({
    type: :goaway, last_stream: (@streams.max.first rescue 0),
    error: error, payload: payload
  })
  @state = :closed
end

#new_stream(**args) ⇒ Object

Allocates new stream for current connection.

Parameters:

  • priority (Integer)
  • window (Integer)
  • parent (Stream)

Raises:



103
104
105
106
107
108
109
110
111
 
# File 'lib/http/2/connection.rb', line 103

def new_stream(**args)
  raise ConnectionClosed.new if @state == :closed
  raise StreamLimitExceeded.new if @active_stream_count >= @remote_settings[:settings_max_concurrent_streams]

  stream = activate_stream(id: @stream_id, **args)
  @stream_id += 2

  stream
end

#ping(payload, &blk) ⇒ Object

Sends PING frame to the peer.

Parameters:

  • payload (String) —

    optional payload must be 8 bytes long

  • blk (Proc) —

    callback to execute when PONG is received



117
118
119
120
 
# File 'lib/http/2/connection.rb', line 117

def ping(payload, &blk)
  send({type: :ping, stream: 0, payload: payload})
  once(:ack, &blk) if blk
end

#receive(data) ⇒ Object Also known as: <<

Decodes incoming bytes into HTTP 2.0 frames and routes them to appropriate receivers: connection frames are handled directly, and stream frames are passed to appropriate stream objects.

Parameters:

  • data (String) —

    Binary encoded string



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
 
# File 'lib/http/2/connection.rb', line 158

def receive(data)
  @recv_buffer << data

  # Upon establishment of a TCP connection and determination that
  # HTTP/2.0 will be used by both peers, each endpoint MUST send a
  # connection header as a final confirmation and to establish the
  # initial settings for the HTTP/2.0 connection.
  #
  # Client connection header is 24 byte connection header followed by
  # SETTINGS frame. Server connection header is SETTINGS frame only.
  if @state == :waiting_magic
    if @recv_buffer.size < 24
      if !CONNECTION_PREFACE_MAGIC.start_with? @recv_buffer
        raise HandshakeError.new
      else
        return # maybe next time
      end

    elsif @recv_buffer.read(24) != CONNECTION_PREFACE_MAGIC
      raise HandshakeError.new
    else
      # MAGIC is OK.  Send our settings
      @state = :waiting_connection_preface
      payload = @local_settings.select {|k,v| v != SPEC_DEFAULT_CONNECTION_SETTINGS[k]}
      settings(payload)
    end
  end

  while frame = @framer.parse(@recv_buffer) do
    emit(:frame_received, frame)

    # Header blocks MUST be transmitted as a contiguous sequence of frames
    # with no interleaved frames of any other type, or from any other stream.
    if !@continuation.empty?
      if frame[:type]  != :continuation ||
         frame[:stream] != @continuation.first[:stream]
        connection_error
      end

      @continuation << frame
      return if !frame[:flags].include? :end_headers

      payload = @continuation.map {|f| f[:payload]}.join

      frame = @continuation.shift
      @continuation.clear

      frame.delete(:length)
      frame[:payload] = Buffer.new(payload)
      frame[:flags] << :end_headers
    end

    # SETTINGS frames always apply to a connection, never a single stream.
    # The stream identifier for a settings frame MUST be zero.  If an
    # endpoint receives a SETTINGS frame whose stream identifier field is
    # anything other than 0x0, the endpoint MUST respond with a connection
    # error (Section 5.4.1) of type PROTOCOL_ERROR.
    if connection_frame?(frame)
      connection_management(frame)
    else
      case frame[:type]
      when :headers
        # The last frame in a sequence of HEADERS/CONTINUATION
        # frames MUST have the END_HEADERS flag set.
        if !frame[:flags].include? :end_headers
          @continuation << frame
          return
        end

        # After sending a GOAWAY frame, the sender can discard frames
        # for new streams.  However, any frames that alter connection
        # state cannot be completely ignored.  For instance, HEADERS,
        # PUSH_PROMISE and CONTINUATION frames MUST be minimally
        # processed to ensure a consistent compression state
        decode_headers(frame)
        return if @state == :closed

        stream = @streams[frame[:stream]]
        if stream.nil?
          stream = activate_stream(id:         frame[:stream],
                                   weight:     frame[:weight]     || DEFAULT_WEIGHT,
                                   dependency: frame[:dependency] || 0,
                                   exclusive:  frame[:exclusive]  || false)
          emit(:stream, stream)
        end

        stream << frame

      when :push_promise
        # The last frame in a sequence of PUSH_PROMISE/CONTINUATION
        # frames MUST have the END_HEADERS flag set
        if !frame[:flags].include? :end_headers
          @continuation << frame
          return
        end

        decode_headers(frame)
        return if @state == :closed

        # PUSH_PROMISE frames MUST be associated with an existing, peer-
        # initiated stream... A receiver MUST treat the receipt of a
        # PUSH_PROMISE on a stream that is neither "open" nor
        # "half-closed (local)" as a connection error (Section 5.4.1) of
        # type PROTOCOL_ERROR. Similarly, a receiver MUST treat the
        # receipt of a PUSH_PROMISE that promises an illegal stream
        # identifier (Section 5.1.1) (that is, an identifier for a stream
        # that is not currently in the "idle" state) as a connection error
        # (Section 5.4.1) of type PROTOCOL_ERROR, unless the receiver
        # recently sent a RST_STREAM frame to cancel the associated stream.
        parent = @streams[frame[:stream]]
        pid = frame[:promise_stream]

        connection_error(msg: 'missing parent ID') if parent.nil?

        if !(parent.state == :open || parent.state == :half_closed_local)
          # An endpoint might receive a PUSH_PROMISE frame after it sends
          # RST_STREAM.  PUSH_PROMISE causes a stream to become "reserved".
          # The RST_STREAM does not cancel any promised stream.  Therefore, if
          # promised streams are not desired, a RST_STREAM can be used to
          # close any of those streams.
          if parent.closed == :local_rst
            # We can either (a) 'resurrect' the parent, or (b) RST_STREAM
            # ... sticking with (b), might need to revisit later.
            send({type: :rst_stream, stream: pid, error: :refused_stream})
          else
            connection_error
          end
        end

        stream = activate_stream(id: pid, parent: parent)
        emit(:promise, stream)
        stream << frame
      else
        if stream = @streams[frame[:stream]]
          stream << frame
        else
          # An endpoint that receives an unexpected stream identifier
          # MUST respond with a connection error of type PROTOCOL_ERROR.
          connection_error
        end
      end
    end
  end

rescue => e
  connection_error
end

#settings(payload) ⇒ Object

Sends a connection SETTINGS frame to the peer. The values are reflected when the corresponding ACK is received.

Parameters:

  • settings (Array or Hash) 


144
145
146
147
148
149
150
151
 
# File 'lib/http/2/connection.rb', line 144

def settings(payload)
  payload = payload.to_a
  check = validate_settings(@local_role, payload)
  check and connection_error
  @pending_settings << payload
  send({type: :settings, stream: 0, payload: payload})
  @pending_settings << payload
end