EmbeddedChannel

public class EmbeddedChannel : Channel

EmbeddedChannel is a Channel implementation that does neither any actual IO nor has a proper eventing mechanism. The prime use-case for EmbeddedChannel is in unit tests when you want to feed the inbound events and check the outbound events manually.

To feed events through an EmbeddedChannel‘s ChannelPipeline use EmbeddedChannel.writeInbound which accepts data of any type. It will then forward that data through the ChannelPipeline and the subsequent ChannelInboundHandler will receive it through the usual channelRead event. The user is responsible for making sure the first ChannelInboundHandler expects data of that type.

EmbeddedChannel automatically collects arriving outbound data and makes it available one-by-one through readOutbound.

Note

Due to #243 EmbeddedChannel expects outbound data to be of IOData type. This is an incorrect and unfortunate assumption that will be fixed with the next major NIO release when we can change the public API again. If you do need to collect outbound data that is not IOData you can create a custom ChannelOutboundHandler, insert it at the very beginning of the ChannelPipeline and collect the outbound data there. Just don’t forward it using ctx.write.

Note

EmbeddedChannel is currently only compatible with EmbeddedEventLoops and cannot be used with SelectableEventLoops from for example MultiThreadedEventLoopGroup.

Warning

Unlike other Channels, EmbeddedChannel is not thread-safe. This is because it is intended to be run in the thread that instantiated it. Users are responsible for ensuring they never call into an EmbeddedChannel in an unsynchronized fashion. EmbeddedEventLoops notes also apply as EmbeddedChannel uses an EmbeddedEventLoop as its EventLoop.

isActive
Declaration
Swift

public var isActive: Bool { get }


                    
                    
                    closeFuture

Declaration

Swift

public var closeFuture: EventLoopFuture<Void> { get }

_unsafe
Declaration
Swift

public var _unsafe: ChannelCore { get }


                    
                    
                    pipeline

Declaration

Swift

public var pipeline: ChannelPipeline { get }

isWritable
Declaration
Swift

public var isWritable: Bool { get }
finish()
Undocumented
Declaration
Swift

public func finish() throws -> Bool


                    
                    
                    allocator

Declaration

Swift

public var allocator: ByteBufferAllocator

eventLoop
Declaration
Swift

public var eventLoop: EventLoop
localAddress
Declaration
Swift

public let localAddress: SocketAddress?


                    
                    
                    remoteAddress

Declaration

Swift

public let remoteAddress: SocketAddress?

parent
Declaration
Swift

public let parent: Channel?
readOutbound()
Undocumented
Declaration
Swift

public func readOutbound() -> IOData?
readInbound()
Undocumented
Declaration
Swift

public func readInbound<T>() -> T?


                    
                    
                    writeInbound(_:)

Writes data into the EmbeddedChannel‘s pipeline. This will result in a channelRead and a channelReadComplete event for the first ChannelHandler.

Declaration

Swift

@discardableResult
public func writeInbound<T>(_ data: T) throws -> Bool

Parameters


                                data

The data to fire through the pipeline.

Return Value

If the inboundBuffer now contains items. The inboundBuffer will be empty until some item travels the ChannelPipeline all the way and hits the tail channel handler.


                    
                    
                    writeOutbound(_:)

Undocumented

Declaration

Swift

@discardableResult
public func writeOutbound<T>(_ data: T) throws -> Bool

throwIfErrorCaught()
Undocumented
Declaration
Swift

public func throwIfErrorCaught() throws


                    
                    
                    init(handler:loop:)

Create a new instance.

During creation it will automatically also register itself on the EmbeddedEventLoop.

Declaration

Swift

public init(handler: ChannelHandler? = nil, loop: EmbeddedEventLoop = EmbeddedEventLoop())

Parameters

`handler`	The `ChannelHandler` to add to the `ChannelPipeline` before register or `nil` if none should be added.
`loop`	The `EmbeddedEventLoop` to use.


                    
                    
                    setOption(option:value:)

Declaration

Swift

public func setOption<T>(option: T, value: T.OptionType) -> EventLoopFuture<Void> where T : ChannelOption


                    
                    
                    getOption(option:)

Declaration

Swift

public func getOption<T>(option: T) -> EventLoopFuture<T.OptionType> where T : ChannelOption