Are there any good examples of an AsyncSequence powered by a ChannelHandler?

George · May 6, 2021, 11:30pm

The PostgresNIO example wasn't exactly what I was looking for, so I wrote my own.

It includes a handler with an async next method (this could theoretically confirm to AsyncIterator directly, but that feels a bit off to me).

github.com

GeorgeLyon/Shwift/blob/5cd82238b9736ec3b9b41bd673ee51d98983f969/Sources/Shwift/Shell.swift#L112-L212


      
          /**
           A handler which can yeild incoming `ByteBuffers` to an asynchronous context
           */
          fileprivate final class Handler: ChannelInboundHandler {
            typealias InboundIn = ByteBuffer
            
            typealias Continuation = CheckedContinuation<[ByteBuffer]?, Swift.Error>
            
            func next() async throws -> [InboundIn]? {
              try await withCheckedThrowingContinuation { continuation in
                context.eventLoop.execute { [self] in
                  
                  /// We expect to only await on handlers that are part of a `ChannelPipeline`
                  precondition(context != nil)
                  
                  switch self.continuation {
                  case let oldValue?:
                    assertionFailure()
                    oldValue.resume(throwing: Error.replacedByNewContinuation)
                  case nil:

This file has been truncated. show original

I then have a simple AsyncIterator which repeatedly calls next on a handler:

github.com

GeorgeLyon/Shwift/blob/5cd82238b9736ec3b9b41bd673ee51d98983f969/Sources/Shwift/Shell.swift#L66-L89


      
          fileprivate struct ByteBuffers: AsyncSequence {
            typealias Element = ByteBuffer
            
            struct AsyncIterator: AsyncIteratorProtocol {
              mutating func next() async throws -> ByteBuffer? {
                if syncIterator == nil {
                  syncIterator = try await handler.next()?.makeIterator()
                }
                return syncIterator?.next()
              }
              
              /// We don't explicitly use `channel` but we do want to keep a
              fileprivate let channel: Channel
              
              fileprivate let handler: Handler
              fileprivate var syncIterator: Array<ByteBuffer>.Iterator?
            }
            __consuming func makeAsyncIterator() -> AsyncIterator {
              return AsyncIterator(channel: channel, handler: handler)
            }

This file has been truncated. show original

@lukasa If this is something that would be interesting to contribute to NIO (and doesn't have any obvious pitfalls I'm missing). I'm not super familiar with the NIO project structure so if someone could point me in the right direction (for instance, where would be a good place for something like this to live), I'd be happy to work up a PR.