1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftNIO open source project
//
// Copyright (c) 2017-2018 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
//
//===----------------------------------------------------------------------===//
/// A `DeadChannelCore` is a `ChannelCore` for a `DeadChannel`. A `DeadChannel` is used as a replacement `Channel` when
/// the original `Channel` is closed. Given that the original `Channel` is closed the `DeadChannelCore` should fail
/// all operations.
private final class DeadChannelCore: ChannelCore {
func localAddress0() throws -> SocketAddress {
throw ChannelError.ioOnClosedChannel
}
func remoteAddress0() throws -> SocketAddress {
throw ChannelError.ioOnClosedChannel
}
func register0(promise: EventLoopPromise<Void>?) {
promise?.fail(ChannelError.ioOnClosedChannel)
}
func registerAlreadyConfigured0(promise: EventLoopPromise<Void>?) {
promise?.fail(ChannelError.ioOnClosedChannel)
}
func bind0(to: SocketAddress, promise: EventLoopPromise<Void>?) {
promise?.fail(ChannelError.ioOnClosedChannel)
}
func connect0(to: SocketAddress, promise: EventLoopPromise<Void>?) {
promise?.fail(ChannelError.ioOnClosedChannel)
}
func write0(_ data: NIOAny, promise: EventLoopPromise<Void>?) {
promise?.fail(ChannelError.ioOnClosedChannel)
}
func flush0() {
}
func read0() {
}
func close0(error: Error, mode: CloseMode, promise: EventLoopPromise<Void>?) {
promise?.fail(ChannelError.alreadyClosed)
}
func triggerUserOutboundEvent0(_ event: Any, promise: EventLoopPromise<Void>?) {
promise?.fail(ChannelError.ioOnClosedChannel)
}
func channelRead0(_ data: NIOAny) {
// a `DeadChannel` should never be in any running `ChannelPipeline` and therefore the `TailChannelHandler`
// should never invoke this.
fatalError("\(#function) called on DeadChannelCore")
}
func errorCaught0(error: Error) {
// a `DeadChannel` should never be in any running `ChannelPipeline` and therefore the `TailChannelHandler`
// should never invoke this.
fatalError("\(#function) called on DeadChannelCore")
}
}
/// This represents a `Channel` which is already closed and therefore all the operations do fail.
/// A `ChannelPipeline` that is associated with a closed `Channel` must be careful to no longer use that original
/// channel as it only holds an unowned reference to the original `Channel`. `DeadChannel` serves as a replacement
/// that can be used when the original `Channel` might no longer be valid.
internal final class DeadChannel: Channel {
let eventLoop: EventLoop
let pipeline: ChannelPipeline
public var closeFuture: EventLoopFuture<Void> {
return self.eventLoop.makeSucceededFuture(())
}
internal init(pipeline: ChannelPipeline) {
self.pipeline = pipeline
self.eventLoop = pipeline.eventLoop
}
// This is `Channel` API so must be thread-safe.
var allocator: ByteBufferAllocator {
return ByteBufferAllocator()
}
var localAddress: SocketAddress? {
return nil
}
var remoteAddress: SocketAddress? {
return nil
}
let parent: Channel? = nil
func setOption<Option: ChannelOption>(_ option: Option, value: Option.Value) -> EventLoopFuture<Void> {
return EventLoopFuture(eventLoop: self.pipeline.eventLoop, error: ChannelError.ioOnClosedChannel, file: #file, line: #line)
}
func getOption<Option: ChannelOption>(_ option: Option) -> EventLoopFuture<Option.Value> {
return eventLoop.makeFailedFuture(ChannelError.ioOnClosedChannel)
}
let isWritable = false
let isActive = false
let _channelCore: ChannelCore = DeadChannelCore()
}
|
