mirror of
https://github.com/apple/swift-nio-http2
synced 2026-11-22 04:30:43 +00:00
998 lines
37 KiB
Swift
998 lines
37 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the SwiftNIO open source project
|
|
//
|
|
// Copyright (c) 2017-2021 Apple Inc. and the SwiftNIO project authors
|
|
// Licensed under Apache License v2.0
|
|
//
|
|
// See LICENSE.txt for license information
|
|
// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
import Atomics
|
|
import NIOConcurrencyHelpers
|
|
import NIOCore
|
|
|
|
/// The various channel options specific to `HTTP2StreamChannel`s.
|
|
///
|
|
/// Please note that some of NIO's regular `ChannelOptions` are valid on `HTTP2StreamChannel`s.
|
|
public struct HTTP2StreamChannelOptions: Sendable {
|
|
/// See ``HTTP2StreamChannelOptions/Types/StreamIDOption``.
|
|
public static let streamID: HTTP2StreamChannelOptions.Types.StreamIDOption = .init()
|
|
}
|
|
|
|
extension HTTP2StreamChannelOptions {
|
|
/// A namespace for the types used to represent HTTP/2 stream channel options.
|
|
public enum Types: Sendable {}
|
|
}
|
|
|
|
@available(*, deprecated, renamed: "HTTP2StreamChannelOptions.Types.StreamIDOption")
|
|
public typealias StreamIDOption = HTTP2StreamChannelOptions.Types.StreamIDOption
|
|
|
|
extension HTTP2StreamChannelOptions.Types {
|
|
/// ``StreamIDOption`` allows users to query the stream ID for a given `HTTP2StreamChannel`.
|
|
///
|
|
/// On active `HTTP2StreamChannel`s, it is possible that a channel handler or user may need to know which
|
|
/// stream ID the channel owns. This channel option allows that query. Please note that this channel option
|
|
/// is *get-only*: that is, it cannot be used with `setOption`. The stream ID for a given `HTTP2StreamChannel`
|
|
/// is immutable.
|
|
///
|
|
/// If a channel is not active, the stream ID will not be present, and attempting to
|
|
/// get this channel option will fail.
|
|
public struct StreamIDOption: ChannelOption {
|
|
public typealias Value = HTTP2StreamID
|
|
|
|
public init() {}
|
|
}
|
|
}
|
|
|
|
/// The current state of a stream channel.
|
|
private enum StreamChannelState {
|
|
/// The stream has been created, but not configured.
|
|
case idle
|
|
|
|
/// The is "active": we haven't sent channelActive yet, but it exists on the network and any shutdown must cause a frame to be emitted.
|
|
case remoteActive
|
|
|
|
/// This is also "active", but different to the above: we've sent channelActive, but the NIOHTTP2Handler hasn't seen the frame yet,
|
|
/// and so we can close this channel without action if needed.
|
|
case localActive
|
|
|
|
/// This is actually active: channelActive has been fired and the HTTP2Handler believes this stream exists.
|
|
case active
|
|
|
|
/// We are closing from a state where channelActive had been fired. In practice this is only ever active, as
|
|
/// in localActive we transition directly to closed.
|
|
case closing
|
|
|
|
/// We're closing from a state where we have never fired channel active, but where the channel was on the network.
|
|
/// This means we need to send frames and wait for their side effects.
|
|
case closingNeverActivated
|
|
|
|
/// We're fully closed.
|
|
case closed
|
|
|
|
mutating func activate() {
|
|
switch self {
|
|
case .idle:
|
|
self = .localActive
|
|
case .remoteActive:
|
|
self = .active
|
|
case .localActive, .active, .closing, .closingNeverActivated, .closed:
|
|
preconditionFailure("Became active from state \(self)")
|
|
}
|
|
}
|
|
|
|
mutating func networkActive() {
|
|
switch self {
|
|
case .idle:
|
|
self = .remoteActive
|
|
case .localActive:
|
|
self = .active
|
|
case .closed:
|
|
preconditionFailure("Stream must be reset on network activation when closed")
|
|
case .remoteActive, .active, .closing, .closingNeverActivated:
|
|
preconditionFailure("Cannot become network active twice, in state \(self)")
|
|
}
|
|
}
|
|
|
|
mutating func beginClosing() {
|
|
switch self {
|
|
case .active, .closing:
|
|
self = .closing
|
|
case .closingNeverActivated, .remoteActive:
|
|
self = .closingNeverActivated
|
|
case .idle, .localActive:
|
|
preconditionFailure("Idle streams immediately close")
|
|
case .closed:
|
|
preconditionFailure("Cannot begin closing while closed")
|
|
}
|
|
}
|
|
|
|
mutating func completeClosing() {
|
|
switch self {
|
|
case .idle, .remoteActive, .closing, .closingNeverActivated, .active, .localActive:
|
|
self = .closed
|
|
case .closed:
|
|
preconditionFailure("Complete closing from \(self)")
|
|
}
|
|
}
|
|
}
|
|
|
|
// The type of data read from and written to the channel.
|
|
enum HTTP2StreamDataType {
|
|
/// `HTTP2Frame`
|
|
case frame
|
|
/// `HTTP2Frame.FramePayload`
|
|
case framePayload
|
|
}
|
|
|
|
private enum HTTP2StreamData {
|
|
case frame(HTTP2Frame)
|
|
case framePayload(HTTP2Frame.FramePayload)
|
|
|
|
var flowControlledSize: Int {
|
|
switch self {
|
|
case .frame(let frame):
|
|
return frame.payload.flowControlledSize
|
|
case .framePayload(let payload):
|
|
return payload.flowControlledSize
|
|
}
|
|
}
|
|
}
|
|
|
|
@usableFromInline
|
|
final class HTTP2StreamChannel: Channel, ChannelCore, @unchecked Sendable {
|
|
// @unchecked Sendable because the only mutable state is `_pipeline` which is only modified in init
|
|
|
|
/// The stream data type of the channel.
|
|
private let streamDataType: HTTP2StreamDataType
|
|
|
|
internal init(
|
|
allocator: ByteBufferAllocator,
|
|
parent: Channel,
|
|
multiplexer: OutboundStreamMultiplexer,
|
|
streamID: HTTP2StreamID?,
|
|
targetWindowSize: Int32,
|
|
outboundBytesHighWatermark: Int,
|
|
outboundBytesLowWatermark: Int,
|
|
streamDataType: HTTP2StreamDataType
|
|
) {
|
|
self.allocator = allocator
|
|
self.closePromise = parent.eventLoop.makePromise()
|
|
self.localAddress = parent.localAddress
|
|
self.remoteAddress = parent.remoteAddress
|
|
self.parent = parent
|
|
self.eventLoop = parent.eventLoop
|
|
self.streamID = streamID
|
|
self.multiplexer = multiplexer
|
|
self.windowManager = InboundWindowManager(targetSize: Int32(targetWindowSize))
|
|
self.flags = NIOLockedValueBox(Flags(isActive: false, isWritable: true))
|
|
self.state = .idle
|
|
self.streamDataType = streamDataType
|
|
self.writabilityManager = StreamChannelFlowController(
|
|
highWatermark: outboundBytesHighWatermark,
|
|
lowWatermark: outboundBytesLowWatermark,
|
|
parentIsWritable: parent.isWritable
|
|
)
|
|
|
|
// To begin with we initialize autoRead to false, but we are going to fetch it from our parent before we
|
|
// go much further.
|
|
self.autoRead = false
|
|
self._pipeline = ChannelPipeline(channel: self)
|
|
}
|
|
|
|
internal func configure(
|
|
initializer: NIOChannelInitializerWithStreamID?,
|
|
userPromise promise: EventLoopPromise<Channel>?
|
|
) {
|
|
assert(self.streamDataType == .frame)
|
|
// We need to configure this channel. This involves doing four things:
|
|
// 1. Setting our autoRead state from the parent
|
|
// 2. Calling the initializer, if provided.
|
|
// 3. Activating when complete.
|
|
// 4. Catching errors if they occur.
|
|
self.getAutoReadFromParent { autoReadResult in
|
|
switch autoReadResult {
|
|
case .success(let autoRead):
|
|
self.autoRead = autoRead
|
|
if let initializer = initializer {
|
|
// This initializer callback can only be invoked if we already have a stream ID.
|
|
// So we force-unwrap here.
|
|
initializer(self, self.streamID!).whenComplete { result in
|
|
self.onInitializationResult(result.map { self }, promise: promise)
|
|
}
|
|
} else {
|
|
self.postInitializerActivate(output: self, promise: promise)
|
|
}
|
|
case .failure(let error):
|
|
self.configurationFailed(withError: error, promise: promise)
|
|
}
|
|
}
|
|
}
|
|
|
|
internal func configure(initializer: NIOChannelInitializer?, userPromise promise: EventLoopPromise<Channel>?) {
|
|
assert(self.streamDataType == .framePayload)
|
|
// We need to configure this channel. This involves doing four things:
|
|
// 1. Setting our autoRead state from the parent
|
|
// 2. Calling the initializer, if provided.
|
|
// 3. Activating when complete.
|
|
// 4. Catching errors if they occur.
|
|
self.getAutoReadFromParent { autoReadResult in
|
|
switch autoReadResult {
|
|
case .success(let autoRead):
|
|
self.autoRead = autoRead
|
|
if let initializer = initializer {
|
|
initializer(self).whenComplete { result in
|
|
self.onInitializationResult(result.map { self }, promise: promise)
|
|
}
|
|
} else {
|
|
self.postInitializerActivate(output: self, promise: promise)
|
|
}
|
|
case .failure(let error):
|
|
self.configurationFailed(withError: error, promise: promise)
|
|
}
|
|
}
|
|
}
|
|
|
|
// This variant is used in the async stream case.
|
|
// It uses `Any`s because when called from `configureInboundStream` it is passed the initializer stored on the handler
|
|
// which can't be a typed generic without changing the handler API.
|
|
internal func configure(
|
|
initializer: @escaping NIOChannelInitializerWithOutput<any Sendable>,
|
|
userPromise promise: EventLoopPromise<any Sendable>?
|
|
) {
|
|
assert(self.streamDataType == .framePayload)
|
|
// We need to configure this channel. This involves doing four things:
|
|
// 1. Setting our autoRead state from the parent
|
|
// 2. Calling the initializer, if provided.
|
|
// 3. Activating when complete.
|
|
// 4. Catching errors if they occur.
|
|
self.getAutoReadFromParent { autoReadResult in
|
|
switch autoReadResult {
|
|
case .success(let autoRead):
|
|
self.autoRead = autoRead
|
|
initializer(self).whenComplete { result in
|
|
self.onInitializationResult(result.map { $0 }, promise: promise)
|
|
}
|
|
case .failure(let error):
|
|
self.configurationFailed(withError: error, promise: promise)
|
|
}
|
|
}
|
|
}
|
|
|
|
func onInitializationResult<Output: Sendable>(
|
|
_ initializerResult: Result<Output, Error>,
|
|
promise: EventLoopPromise<Output>?
|
|
) {
|
|
switch initializerResult {
|
|
case .success(let output):
|
|
self.postInitializerActivate(output: output, promise: promise)
|
|
case .failure(let error):
|
|
self.configurationFailed(withError: error, promise: promise)
|
|
}
|
|
}
|
|
|
|
/// Gets the 'autoRead' option from the parent channel and invokes the `body` closure with the
|
|
/// result. This may be done synchronously if the parent `Channel` supports synchronous options.
|
|
private func getAutoReadFromParent(_ body: @Sendable @escaping (Result<Bool, Error>) -> Void) {
|
|
// This force unwrap is safe as parent is assigned in the initializer, and never unassigned.
|
|
// Note we also don't set the value here: the additional `map` causes an extra allocation
|
|
// when using a Swift 5.0 compiler.
|
|
if let syncOptions = self.parent!.syncOptions {
|
|
let autoRead = Result(catching: { try syncOptions.getOption(ChannelOptions.autoRead) })
|
|
body(autoRead)
|
|
} else {
|
|
self.parent!.getOption(ChannelOptions.autoRead).whenComplete { autoRead in
|
|
body(autoRead)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Activates the channel if the parent channel is active and succeeds the given `promise`.
|
|
private func postInitializerActivate<Output: Sendable>(output: Output, promise: EventLoopPromise<Output>?) {
|
|
// This force unwrap is safe as parent is assigned in the initializer, and never unassigned.
|
|
// If parent is not active, we expect to receive a channelActive later.
|
|
if self.parent!.isActive {
|
|
self.performActivation()
|
|
}
|
|
|
|
// We aren't using cascade here to avoid the allocations it causes.
|
|
promise?.succeed(output)
|
|
}
|
|
|
|
/// Handle any error that occurred during configuration.
|
|
private func configurationFailed<Output: Sendable>(withError error: Error, promise: EventLoopPromise<Output>?) {
|
|
switch self.state {
|
|
case .idle, .localActive, .closed:
|
|
// The stream isn't open on the network, nothing to close.
|
|
self.errorEncountered(error: error)
|
|
case .remoteActive, .active, .closing, .closingNeverActivated:
|
|
// In all of these states the stream is still on the network and we may need to take action.
|
|
self.closedWhileOpen()
|
|
}
|
|
|
|
promise?.fail(error)
|
|
}
|
|
|
|
/// Activates this channel.
|
|
internal func performActivation() {
|
|
precondition(self.parent?.isActive ?? false, "Parent must be active to activate the child")
|
|
|
|
if self.state == .closed || self.state == .closingNeverActivated {
|
|
// We're already closed, or we've been asked to close and are waiting for the network.
|
|
// No need to activate in either case
|
|
return
|
|
}
|
|
|
|
self.modifyingState { $0.activate() }
|
|
self.pipeline.fireChannelActive()
|
|
self.tryToAutoRead()
|
|
self.deliverPendingWrites()
|
|
}
|
|
|
|
internal func networkActivationReceived() {
|
|
if self.state == .closed {
|
|
// Uh-oh: we got an activation but we think we're closed! We need to send a RST_STREAM frame. We'll only do it if we have a stream ID.
|
|
if let streamID = self.streamID {
|
|
let resetFrame = HTTP2Frame(streamID: streamID, payload: .rstStream(.cancel))
|
|
self.parent?.writeAndFlush(resetFrame, promise: nil)
|
|
}
|
|
return
|
|
}
|
|
self.modifyingState { $0.networkActive() }
|
|
|
|
let writabilityChanged = self.flags.withLockedValue {
|
|
if self.writabilityManager.isWritable != $0.isWritable {
|
|
$0.isWritable.toggle()
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// We have probably delayed telling the user that this channel isn't writable, but we should do
|
|
// it now.
|
|
if writabilityChanged {
|
|
self.pipeline.fireChannelWritabilityChanged()
|
|
}
|
|
|
|
// If we got here, we may need to flush some pending reads. Notably we don't call read0 here as
|
|
// we don't actually want to start reading before activation, which tryToRead will refuse to do.
|
|
if self.pendingReads.count > 0 {
|
|
self.tryToRead()
|
|
}
|
|
}
|
|
|
|
private var _pipeline: ChannelPipeline!
|
|
|
|
public let allocator: ByteBufferAllocator
|
|
|
|
private let closePromise: EventLoopPromise<()>
|
|
|
|
private let multiplexer: OutboundStreamMultiplexer
|
|
|
|
public var closeFuture: EventLoopFuture<Void> {
|
|
self.closePromise.futureResult
|
|
}
|
|
|
|
public var pipeline: ChannelPipeline {
|
|
self._pipeline
|
|
}
|
|
|
|
public let localAddress: SocketAddress?
|
|
|
|
public let remoteAddress: SocketAddress?
|
|
|
|
public let parent: Channel?
|
|
|
|
@usableFromInline
|
|
func localAddress0() throws -> SocketAddress {
|
|
fatalError()
|
|
}
|
|
|
|
@usableFromInline
|
|
func remoteAddress0() throws -> SocketAddress {
|
|
fatalError()
|
|
}
|
|
|
|
@usableFromInline
|
|
func setOption<Option: ChannelOption>(_ option: Option, value: Option.Value) -> EventLoopFuture<Void> {
|
|
if self.eventLoop.inEventLoop {
|
|
do {
|
|
return self.eventLoop.makeSucceededFuture(try self.setOption0(option, value: value))
|
|
} catch {
|
|
return self.eventLoop.makeFailedFuture(error)
|
|
}
|
|
} else {
|
|
return self.eventLoop.submit { try self.setOption0(option, value: value) }
|
|
}
|
|
}
|
|
|
|
public func getOption<Option: ChannelOption>(_ option: Option) -> EventLoopFuture<Option.Value> {
|
|
if self.eventLoop.inEventLoop {
|
|
do {
|
|
return self.eventLoop.makeSucceededFuture(try self.getOption0(option))
|
|
} catch {
|
|
return self.eventLoop.makeFailedFuture(error)
|
|
}
|
|
} else {
|
|
return self.eventLoop.submit { try self.getOption0(option) }
|
|
}
|
|
}
|
|
|
|
private func setOption0<Option: ChannelOption>(_ option: Option, value: Option.Value) throws {
|
|
self.eventLoop.preconditionInEventLoop()
|
|
|
|
switch option {
|
|
case _ as ChannelOptions.Types.AutoReadOption:
|
|
self.autoRead = value as! Bool
|
|
default:
|
|
fatalError("setting option \(option) on HTTP2StreamChannel not supported")
|
|
}
|
|
}
|
|
|
|
private func getOption0<Option: ChannelOption>(_ option: Option) throws -> Option.Value {
|
|
self.eventLoop.preconditionInEventLoop()
|
|
|
|
switch option {
|
|
case _ as HTTP2StreamChannelOptions.Types.StreamIDOption:
|
|
if let streamID = self.streamID {
|
|
return streamID as! Option.Value
|
|
} else {
|
|
throw NIOHTTP2Errors.noStreamIDAvailable()
|
|
}
|
|
case _ as ChannelOptions.Types.AutoReadOption:
|
|
return self.autoRead as! Option.Value
|
|
default:
|
|
fatalError("option \(option) not supported on HTTP2StreamChannel")
|
|
}
|
|
}
|
|
|
|
private struct Flags {
|
|
var isActive: Bool
|
|
var isWritable: Bool
|
|
}
|
|
|
|
private let flags: NIOLockedValueBox<Flags>
|
|
|
|
public var isWritable: Bool {
|
|
self.flags.withLockedValue { $0.isWritable }
|
|
}
|
|
|
|
private var _isActive: Bool {
|
|
self.state == .active || self.state == .closing || self.state == .localActive
|
|
}
|
|
|
|
public var isActive: Bool {
|
|
self.flags.withLockedValue { $0.isActive }
|
|
}
|
|
|
|
public var _channelCore: ChannelCore {
|
|
self
|
|
}
|
|
|
|
public let eventLoop: EventLoop
|
|
|
|
internal var streamID: HTTP2StreamID?
|
|
|
|
private var state: StreamChannelState
|
|
|
|
private var windowManager: InboundWindowManager
|
|
|
|
/// If close0 was called but the stream could not synchronously close (because it's currently
|
|
/// active), the promise is stored here until it can be fulfilled.
|
|
private var pendingClosePromise: EventLoopPromise<Void>?
|
|
|
|
/// A buffer of pending inbound reads delivered from the parent channel.
|
|
///
|
|
/// In the future this buffer will be used to manage interactions with read() and even, one day,
|
|
/// with flow control. For now, though, all this does is hold frames until we have set the
|
|
/// channel up.
|
|
private var pendingReads: CircularBuffer<HTTP2Frame> = CircularBuffer(initialCapacity: 8)
|
|
|
|
/// Whether `autoRead` is enabled. By default, all `HTTP2StreamChannel` objects inherit their `autoRead`
|
|
/// state from their parent.
|
|
private var autoRead: Bool
|
|
|
|
/// Whether a call to `read` has happened without any frames available to read (that is, whether newly
|
|
/// received frames should be immediately delivered to the pipeline).
|
|
private var unsatisfiedRead: Bool = false
|
|
|
|
/// A buffer of pending outbound writes to deliver to the parent channel.
|
|
///
|
|
/// To correctly respect flushes, we deliberately withold frames from the parent channel until this
|
|
/// stream is flushed, at which time we deliver them all. This buffer holds the pending ones.
|
|
private var pendingWrites: MarkedCircularBuffer<(HTTP2StreamData, EventLoopPromise<Void>?)> = MarkedCircularBuffer(
|
|
initialCapacity: 8
|
|
)
|
|
|
|
/// A list node used to hold stream channels.
|
|
internal var streamChannelListNode: StreamChannelListNode = StreamChannelListNode()
|
|
|
|
/// An object that controls whether this channel should be writable.
|
|
private var writabilityManager: StreamChannelFlowController
|
|
|
|
public func register0(promise: EventLoopPromise<Void>?) {
|
|
fatalError("not implemented \(#function)")
|
|
}
|
|
|
|
public func bind0(to: SocketAddress, promise: EventLoopPromise<Void>?) {
|
|
fatalError("not implemented \(#function)")
|
|
}
|
|
|
|
public func connect0(to: SocketAddress, promise: EventLoopPromise<Void>?) {
|
|
fatalError("not implemented \(#function)")
|
|
}
|
|
|
|
func wroteBytes(_ writeSize: Int) {
|
|
self.eventLoop.preconditionInEventLoop()
|
|
if case .changed(newValue: let value) = self.writabilityManager.wroteBytes(writeSize) {
|
|
self.changeWritability(to: value)
|
|
}
|
|
}
|
|
|
|
public func write0(_ data: NIOAny, promise userPromise: EventLoopPromise<Void>?) {
|
|
guard self.state != .closed else {
|
|
userPromise?.fail(ChannelError._ioOnClosedChannel)
|
|
return
|
|
}
|
|
|
|
let streamData: HTTP2StreamData
|
|
switch self.streamDataType {
|
|
case .frame:
|
|
streamData = .frame(self.unwrapData(data))
|
|
case .framePayload:
|
|
streamData = .framePayload(self.unwrapData(data))
|
|
}
|
|
|
|
// For the legacy case we need a promise to attach our flow control callback to.
|
|
//
|
|
// This is no longer needed for the `.inline` stream multiplexer case for which this
|
|
// is all dealt with within the `NIOHTTP2Handler` which calls us back directly
|
|
// via `wroteBytes`.
|
|
//
|
|
// Regardless of whether the write succeeded or failed, we don't count
|
|
// the bytes any longer.
|
|
let promise: EventLoopPromise<Void>?
|
|
let writeSize = streamData.flowControlledSize
|
|
|
|
switch self.multiplexer {
|
|
case .inline:
|
|
promise = userPromise
|
|
break // do nothing at this stage, we'll be called back
|
|
case .legacy:
|
|
promise = userPromise ?? self.eventLoop.makePromise()
|
|
promise!.futureResult.hop(to: self.eventLoop).whenComplete { (_: Result<Void, Error>) in
|
|
self.wroteBytes(writeSize)
|
|
}
|
|
}
|
|
|
|
self.pendingWrites.append((streamData, promise))
|
|
|
|
// Ok, we can make an outcall now, which means we can safely deal with the flow control.
|
|
if case .changed(newValue: let value) = self.writabilityManager.bufferedBytes(writeSize) {
|
|
self.changeWritability(to: value)
|
|
}
|
|
}
|
|
|
|
public func flush0() {
|
|
self.pendingWrites.mark()
|
|
|
|
if self._isActive {
|
|
self.deliverPendingWrites()
|
|
}
|
|
}
|
|
|
|
public func read0() {
|
|
if self.unsatisfiedRead {
|
|
// We already have an unsatisfied read, let's do nothing.
|
|
return
|
|
}
|
|
|
|
// At this stage, we have an unsatisfied read. If there is no pending data to read,
|
|
// we're going to call read() on the parent channel. Otherwise, we're going to
|
|
// succeed the read out of our pending data.
|
|
self.unsatisfiedRead = true
|
|
if self.pendingReads.count > 0 {
|
|
self.tryToRead()
|
|
} else {
|
|
self.parent?.read()
|
|
}
|
|
}
|
|
|
|
public func close0(error: Error, mode: CloseMode, promise: EventLoopPromise<Void>?) {
|
|
// If the stream is already closed, we can fail this early and abort processing. If it's not, we need to emit a
|
|
// RST_STREAM frame.
|
|
guard self.state != .closed else {
|
|
promise?.fail(ChannelError._alreadyClosed)
|
|
return
|
|
}
|
|
|
|
// Store the pending close promise: it'll be succeeded later.
|
|
if let promise = promise {
|
|
if let pendingPromise = self.pendingClosePromise {
|
|
pendingPromise.futureResult.cascade(to: promise)
|
|
} else {
|
|
self.pendingClosePromise = promise
|
|
}
|
|
}
|
|
|
|
switch self.state {
|
|
case .idle, .localActive, .closed:
|
|
// The stream isn't open on the network, just go straight to closed cleanly.
|
|
self.closedCleanly()
|
|
case .remoteActive, .active, .closing, .closingNeverActivated:
|
|
// In all of these states the stream is still on the network and we need to wait.
|
|
self.closedWhileOpen()
|
|
}
|
|
}
|
|
|
|
public func triggerUserOutboundEvent0(_ event: Any, promise: EventLoopPromise<Void>?) {
|
|
// do nothing
|
|
}
|
|
|
|
public func channelRead0(_ data: NIOAny) {
|
|
// do nothing
|
|
}
|
|
|
|
public func errorCaught0(error: Error) {
|
|
// do nothing
|
|
}
|
|
|
|
/// Called when the channel was closed from the pipeline while the stream is still open.
|
|
///
|
|
/// Will emit a RST_STREAM frame in order to close the stream. Note that this function does not
|
|
/// directly close the stream: it waits until the stream closed notification is fired.
|
|
private func closedWhileOpen() {
|
|
precondition(self.state != .closed)
|
|
guard self.state != .closing else {
|
|
// If we're already closing, nothing to do here.
|
|
return
|
|
}
|
|
|
|
self.modifyingState { $0.beginClosing() }
|
|
// We should have a stream ID here, force-unwrap is safe.
|
|
let resetFrame = HTTP2Frame(streamID: self.streamID!, payload: .rstStream(.cancel))
|
|
self.receiveOutboundFrame(resetFrame, promise: nil)
|
|
self.multiplexer.flushStream(self.streamID!)
|
|
}
|
|
|
|
private func closedCleanly() {
|
|
guard self.state != .closed else {
|
|
return
|
|
}
|
|
self.modifyingState { $0.completeClosing() }
|
|
self.dropPendingReads()
|
|
self.failPendingWrites(error: ChannelError._eof)
|
|
if let promise = self.pendingClosePromise {
|
|
self.pendingClosePromise = nil
|
|
promise.succeed(())
|
|
}
|
|
self.pipeline.fireChannelInactive()
|
|
|
|
self.eventLoop.execute {
|
|
self.removeHandlers(pipeline: self.pipeline)
|
|
self.closePromise.succeed()
|
|
if let streamID = self.streamID {
|
|
self.multiplexer.streamClosed(id: streamID)
|
|
} else {
|
|
self.multiplexer.streamClosed(channelID: ObjectIdentifier(self))
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate func errorEncountered(error: Error) {
|
|
guard self.state != .closed else {
|
|
return
|
|
}
|
|
self.modifyingState { $0.completeClosing() }
|
|
self.dropPendingReads()
|
|
self.failPendingWrites(error: error)
|
|
if let promise = self.pendingClosePromise {
|
|
self.pendingClosePromise = nil
|
|
promise.fail(error)
|
|
}
|
|
self.pipeline.fireErrorCaught(error)
|
|
self.pipeline.fireChannelInactive()
|
|
|
|
self.eventLoop.execute {
|
|
self.removeHandlers(pipeline: self.pipeline)
|
|
self.closePromise.succeed()
|
|
if let streamID = self.streamID {
|
|
self.multiplexer.streamClosed(id: streamID)
|
|
} else {
|
|
self.multiplexer.streamClosed(channelID: ObjectIdentifier(self))
|
|
}
|
|
}
|
|
}
|
|
|
|
private func tryToRead() {
|
|
// If there's no read to satisfy, no worries about it.
|
|
guard self.unsatisfiedRead else {
|
|
return
|
|
}
|
|
|
|
// If we're not active, we will hold on to these reads.
|
|
guard self._isActive else {
|
|
return
|
|
}
|
|
|
|
// If there are no pending reads, do nothing.
|
|
guard self.pendingReads.count > 0 else {
|
|
return
|
|
}
|
|
|
|
// Ok, we're satisfying a read here.
|
|
self.unsatisfiedRead = false
|
|
self.deliverPendingReads()
|
|
self.tryToAutoRead()
|
|
}
|
|
|
|
private func changeWritability(to newWritability: Bool) {
|
|
self.flags.withLockedValue { $0.isWritable = newWritability }
|
|
self.pipeline.fireChannelWritabilityChanged()
|
|
}
|
|
|
|
private func tryToAutoRead() {
|
|
if self.autoRead {
|
|
// If auto-read is turned on, recurse into channelPipeline.read().
|
|
// This cannot recurse indefinitely unless frames are being delivered
|
|
// by the read stacks, which is generally fairly unlikely to continue unbounded.
|
|
self.pipeline.read()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK:- Functions used to manage pending reads and writes.
|
|
extension HTTP2StreamChannel {
|
|
/// Drop all pending reads.
|
|
private func dropPendingReads() {
|
|
/// We don't need to report the dropped reads, just remove them all.
|
|
self.pendingReads.removeAll(keepingCapacity: true)
|
|
}
|
|
|
|
/// Deliver all pending reads to the channel.
|
|
private func deliverPendingReads() {
|
|
assert(self._isActive)
|
|
while self.pendingReads.count > 0 {
|
|
let frame = self.pendingReads.removeFirst()
|
|
|
|
let dataLength: Int?
|
|
|
|
switch frame.payload {
|
|
case .data(let data):
|
|
dataLength = data.data.readableBytes
|
|
default:
|
|
dataLength = nil
|
|
}
|
|
|
|
switch self.streamDataType {
|
|
case .frame:
|
|
self.pipeline.fireChannelRead(frame)
|
|
case .framePayload:
|
|
self.pipeline.fireChannelRead(frame.payload)
|
|
}
|
|
|
|
if let size = dataLength, let increment = self.windowManager.bufferedFrameEmitted(size: size) {
|
|
// To have a pending read, we must have a stream ID.
|
|
let frame = HTTP2Frame(streamID: self.streamID!, payload: .windowUpdate(windowSizeIncrement: increment))
|
|
self.receiveOutboundFrame(frame, promise: nil)
|
|
// This flush should really go away, but we need it for now until we sort out window management.
|
|
self.multiplexer.flushStream(self.streamID!)
|
|
}
|
|
}
|
|
self.pipeline.fireChannelReadComplete()
|
|
}
|
|
|
|
/// Delivers all pending flushed writes to the parent channel.
|
|
private func deliverPendingWrites() {
|
|
// If there are no pending writes, don't bother with the processing.
|
|
guard self.pendingWrites.hasMark else {
|
|
return
|
|
}
|
|
|
|
// Get a streamID from the multiplexer if we haven't got one already.
|
|
if self.streamID == nil {
|
|
self.streamID = self.multiplexer.requestStreamID(forChannel: self)
|
|
}
|
|
|
|
while self.pendingWrites.hasMark {
|
|
let (streamData, promise) = self.pendingWrites.removeFirst()
|
|
let frame: HTTP2Frame
|
|
|
|
switch streamData {
|
|
case .frame(let f):
|
|
frame = f
|
|
case .framePayload(let payload):
|
|
// This unwrap is okay: we just ensured that `self.streamID` was set above.
|
|
frame = HTTP2Frame(streamID: self.streamID!, payload: payload)
|
|
}
|
|
|
|
self.receiveOutboundFrame(frame, promise: promise)
|
|
}
|
|
self.multiplexer.flushStream(self.streamID!)
|
|
}
|
|
|
|
/// Fails all pending writes with the given error.
|
|
private func failPendingWrites(error: Error) {
|
|
assert(self.state == .closed)
|
|
while self.pendingWrites.count > 0 {
|
|
self.pendingWrites.removeFirst().1?.fail(error)
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK:- Functions used to communicate between the `HTTP2StreamMultiplexer` and the `HTTP2StreamChannel`.
|
|
extension HTTP2StreamChannel {
|
|
/// Called when a frame is received from the network.
|
|
///
|
|
/// - Parameters:
|
|
/// - frame: The `HTTP2Frame` received from the network.
|
|
func receiveInboundFrame(_ frame: HTTP2Frame) {
|
|
guard self.state != .closed else {
|
|
// Do nothing
|
|
return
|
|
}
|
|
|
|
// Record the size of the frame so that when we receive a window update event our
|
|
// calculation on whether we emit a WINDOW_UPDATE frame is based on the bytes we have
|
|
// actually delivered into the pipeline.
|
|
if case .data(let dataPayload) = frame.payload {
|
|
self.windowManager.bufferedFrameReceived(size: dataPayload.data.readableBytes)
|
|
|
|
// No further window update frames should be sent.
|
|
if dataPayload.endStream {
|
|
self.windowManager.closed = true
|
|
}
|
|
} else if case .headers(let headersPayload) = frame.payload, headersPayload.endStream {
|
|
// No further window update frames should be sent.
|
|
self.windowManager.closed = true
|
|
}
|
|
|
|
self.pendingReads.append(frame)
|
|
}
|
|
|
|
/// Called when a frame is sent to the network.
|
|
///
|
|
/// - Parameters:
|
|
/// - frame: The `HTTP2Frame` to send to the network.
|
|
/// - promise: The promise associated with the frame write.
|
|
private func receiveOutboundFrame(_ frame: HTTP2Frame, promise: EventLoopPromise<Void>?) {
|
|
guard self.state != .closed else {
|
|
let error = ChannelError._alreadyClosed
|
|
promise?.fail(error)
|
|
self.errorEncountered(error: error)
|
|
return
|
|
}
|
|
self.multiplexer.writeFrame(frame, promise: promise)
|
|
}
|
|
|
|
/// Called when a stream closure is received from the network.
|
|
///
|
|
/// - Parameters:
|
|
/// - reason: The reason received from the network, if any.
|
|
func receiveStreamClosed(_ reason: HTTP2ErrorCode?) {
|
|
// Avoid emitting any WINDOW_UPDATE frames now that we're closed.
|
|
self.windowManager.closed = true
|
|
|
|
// The stream is closed, we should force forward all pending frames, even without
|
|
// unsatisfied read, to ensure the handlers can see all frames before receiving
|
|
// channelInactive.
|
|
if self.pendingReads.count > 0 && self._isActive {
|
|
self.unsatisfiedRead = false
|
|
self.deliverPendingReads()
|
|
}
|
|
|
|
if let reason = reason {
|
|
// To receive from the network, it must be safe to force-unwrap here.
|
|
let err = NIOHTTP2Errors.streamClosed(streamID: self.streamID!, errorCode: reason)
|
|
self.errorEncountered(error: err)
|
|
} else {
|
|
self.closedCleanly()
|
|
}
|
|
}
|
|
|
|
func receiveWindowUpdatedEvent(_ windowSize: Int) {
|
|
if let increment = self.windowManager.newWindowSize(windowSize) {
|
|
// To receive from the network, it must be safe to force-unwrap here.
|
|
let frame = HTTP2Frame(streamID: self.streamID!, payload: .windowUpdate(windowSizeIncrement: increment))
|
|
self.receiveOutboundFrame(frame, promise: nil)
|
|
// This flush should really go away, but we need it for now until we sort out window management.
|
|
self.multiplexer.flushStream(self.streamID!)
|
|
}
|
|
}
|
|
|
|
func initialWindowSizeChanged(delta: Int) {
|
|
if let increment = self.windowManager.initialWindowSizeChanged(delta: delta) {
|
|
// To receive from the network, it must be safe to force-unwrap here.
|
|
let frame = HTTP2Frame(streamID: self.streamID!, payload: .windowUpdate(windowSizeIncrement: increment))
|
|
self.receiveOutboundFrame(frame, promise: nil)
|
|
// This flush should really go away, but we need it for now until we sort out window management.
|
|
self.multiplexer.flushStream(self.streamID!)
|
|
}
|
|
}
|
|
|
|
func receiveParentChannelReadComplete() {
|
|
self.tryToRead()
|
|
}
|
|
|
|
func parentChannelWritabilityChanged(newValue: Bool) {
|
|
// There's a trick here that's worth noting: if the child channel hasn't either sent a frame
|
|
// or been activated on the network, we don't actually want to change the observable writability.
|
|
// This is because in this case we really want user code to send a frame as soon as possible to avoid
|
|
// issues with their stream ID becoming out of date. Once the state transitions we can update
|
|
// the writability if needed.
|
|
guard case .changed(newValue: let localValue) = self.writabilityManager.parentWritabilityChanged(newValue)
|
|
else {
|
|
return
|
|
}
|
|
|
|
// Ok, the writability changed.
|
|
switch self.state {
|
|
case .idle, .localActive:
|
|
// Do nothing here.
|
|
return
|
|
case .remoteActive, .active, .closing, .closingNeverActivated, .closed:
|
|
self.flags.withLockedValue { $0.isWritable = localValue }
|
|
self.pipeline.fireChannelWritabilityChanged()
|
|
}
|
|
}
|
|
|
|
func receiveStreamError(_ error: NIOHTTP2Errors.StreamError) {
|
|
assert(error.streamID == self.streamID)
|
|
self.pipeline.fireErrorCaught(error.baseError)
|
|
}
|
|
}
|
|
|
|
extension HTTP2StreamChannel {
|
|
// A helper function used to ensure that state modification leads to changes in the channel active atomic.
|
|
private func modifyingState<ReturnType>(
|
|
_ closure: (inout StreamChannelState) throws -> ReturnType
|
|
) rethrows -> ReturnType {
|
|
defer {
|
|
self.flags.withLockedValue { $0.isActive = self._isActive }
|
|
}
|
|
return try closure(&self.state)
|
|
}
|
|
}
|
|
|
|
// MARK: Custom String Convertible
|
|
extension HTTP2StreamChannel {
|
|
public var description: String {
|
|
"HTTP2StreamChannel(streamID: \(String(describing: self.streamID)), isActive: \(self.isActive), isWritable: \(self.isWritable))"
|
|
}
|
|
}
|
|
|
|
extension HTTP2StreamChannel {
|
|
internal struct SynchronousOptions: NIOSynchronousChannelOptions {
|
|
private let channel: HTTP2StreamChannel
|
|
|
|
fileprivate init(channel: HTTP2StreamChannel) {
|
|
self.channel = channel
|
|
}
|
|
|
|
/// Set `option` to `value` on this `Channel`.
|
|
///
|
|
/// - Important: Must be called on the `EventLoop` the `Channel` is running on.
|
|
public func setOption<Option: ChannelOption>(_ option: Option, value: Option.Value) throws {
|
|
try self.channel.setOption0(option, value: value)
|
|
}
|
|
|
|
/// Get the value of `option` for this `Channel`.
|
|
///
|
|
/// - Important: Must be called on the `EventLoop` the `Channel` is running on.
|
|
public func getOption<Option: ChannelOption>(_ option: Option) throws -> Option.Value {
|
|
try self.channel.getOption0(option)
|
|
}
|
|
}
|
|
|
|
/// Returns a view of the `Channel` exposing synchronous versions of `setOption` and `getOption`.
|
|
public var syncOptions: NIOSynchronousChannelOptions? {
|
|
SynchronousOptions(channel: self)
|
|
}
|
|
}
|