Move Channel abstractions to NIOCore. (#1920)

Motivation:

The most important API surface area in NIO are the Channel abstractions.
These are shared in all NIO programs, and are also used by several
projects to implement their I/O abstraction. There are several moving
parts to this abstraction, all of which are moving:

- Channel itself
- ChannelPipeline
- ChannelHandler

As these all move, they force several other pieces of API to move with
them. Most notably they force us to move NIOAny, which also forces us to
move FileHandle and FileRegion. That also forces us to bring over part
of our syscall abstraction. This duplication is acceptable due to its
minimal surface area, but it is definitely a flaw in our abstraction
design that we had to do that at all.

We also need to move the channel option abstraction, AddressedEnvelope,
and the DeadChannel.

Modifications:

- Moved a bunch of the Channel abstraction over.
- Moved Channel-associated types.

Result:

Channel will be part of NIOCore.

Author: Lukasa

Sources/NIO/BaseStreamSocketChannel.swift

@@ -247,7 +247,7 @@ class BaseStreamSocketChannel<Socket: SocketProtocol>: BaseSocketChannel<Socket>
             return
         }
 
-        let data = data.forceAsIOData()
+        let data = self.unwrapData(data, as: IOData.self)
 
         if !self.pendingWrites.add(data: data, promise: promise) {
             self.pipeline.syncOperations.fireChannelWritabilityChanged()

Sources/NIO/Bootstrap.swift

@@ -362,7 +362,7 @@ public final class ServerBootstrap {
                 ctxEventLoop.assertInEventLoop()
                 future.flatMap { (_) -> EventLoopFuture<Void> in
                     ctxEventLoop.assertInEventLoop()
-                    guard !context.pipeline.destroyed else {
+                    guard context.channel.isActive else {
                         return context.eventLoop.makeFailedFuture(ChannelError.ioOnClosedChannel)
                     }
                     context.fireChannelRead(data)

Sources/NIO/Embedded.swift

@@ -237,7 +237,8 @@ class EmbeddedChannelCore: ChannelCore {
     }
 
     deinit {
-        assert(self.pipeline.destroyed, "leaked an open EmbeddedChannel, maybe forgot to call channel.finish()?")
+        assert(!self.isOpen && !self.isActive,
+               "leaked an open EmbeddedChannel, maybe forgot to call channel.finish()?")
         isOpen = false
         closePromise.succeed(())
     }
@@ -631,7 +632,7 @@ public final class EmbeddedChannel: Channel {
         }
         let elem = buffer.removeFirst()
         guard let t = self._channelCore.tryUnwrapData(elem, as: T.self) else {
-            throw WrongTypeError(expected: T.self, actual: type(of: elem.forceAs(type: Any.self)))
+            throw WrongTypeError(expected: T.self, actual: type(of: self._channelCore.tryUnwrapData(elem, as: Any.self)!))
         }
         return t
     }

Sources/NIO/FileDescriptor.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the SwiftNIO open source project
 //
-// Copyright (c) 2017-2018 Apple Inc. and the SwiftNIO project authors
+// Copyright (c) 2017-2021 Apple Inc. and the SwiftNIO project authors
 // Licensed under Apache License v2.0
 //
 // See LICENSE.txt for license information
@@ -12,26 +12,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-public protocol FileDescriptor {
-
-    /// Will be called with the file descriptor if still open, if not it will
-    /// throw an `IOError`.
-    ///
-    /// The ownership of the file descriptor must not escape the `body` as it's completely managed by the
-    /// implementation of the `FileDescriptor` protocol.
-    ///
-    /// - parameters:
-    ///     - body: The closure to execute if the `FileDescriptor` is still open.
-    /// - throws: If either the `FileDescriptor` was closed before or the closure throws by itself.
-    func withUnsafeFileDescriptor<T>(_ body: (CInt) throws -> T) throws -> T
-
-    /// `true` if this `FileDescriptor` is open (which means it was not closed yet).
-    var isOpen: Bool { get }
-
-    /// Close this `FileDescriptor`.
-    func close() throws
-}
-
 extension FileDescriptor {
     internal static func setNonBlocking(fileDescriptor: CInt) throws {
         let flags = try Posix.fcntl(descriptor: fileDescriptor, command: F_GETFL, value: 0)

Sources/NIO/Interfaces.swift renamed to Sources/NIO/NetworkDevices.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the SwiftNIO open source project
 //
-// Copyright (c) 2017-2018 Apple Inc. and the SwiftNIO project authors
+// Copyright (c) 2017-2021 Apple Inc. and the SwiftNIO project authors
 // Licensed under Apache License v2.0
 //
 // See LICENSE.txt for license information
@@ -11,12 +11,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 //===----------------------------------------------------------------------===//
-//
-//  Interfaces.swift
-//  NIO
-//
-//  Created by Cory Benfield on 27/02/2018.
-//
 
 #if os(Linux) || os(FreeBSD) || os(Android)
 import CNIOLinux
@@ -371,158 +365,3 @@ extension NIONetworkDevice: Hashable {
         hasher.combine(self.interfaceIndex)
     }
 }
-
-/// A representation of a single network interface on a system.
-@available(*, deprecated, renamed: "NIONetworkDevice")
-public final class NIONetworkInterface {
-    // This is a class because in almost all cases this will carry
-    // four structs that are backed by classes, and so will incur 4
-    // refcount operations each time it is copied.
-
-    /// The name of the network interface.
-    public let name: String
-
-    /// The address associated with the given network interface.
-    public let address: SocketAddress
-
-    /// The netmask associated with this address, if any.
-    public let netmask: SocketAddress?
-
-    /// The broadcast address associated with this socket interface, if it has one. Some
-    /// interfaces do not, especially those that have a `pointToPointDestinationAddress`.
-    public let broadcastAddress: SocketAddress?
-
-    /// The address of the peer on a point-to-point interface, if this is one. Some
-    /// interfaces do not have such an address: most of those have a `broadcastAddress`
-    /// instead.
-    public let pointToPointDestinationAddress: SocketAddress?
-
-    /// If the Interface supports Multicast
-    public let multicastSupported: Bool
-
-    /// The index of the interface, as provided by `if_nametoindex`.
-    public let interfaceIndex: Int
-
-    /// Create a brand new network interface.
-    ///
-    /// This constructor will fail if NIO does not understand the format of the underlying
-    /// socket address family. This is quite common: for example, Linux will return AF_PACKET
-    /// addressed interfaces on most platforms, which NIO does not currently understand.
-#if os(Windows)
-    internal init?(_ pAdapter: UnsafeMutablePointer<IP_ADAPTER_ADDRESSES>,
-                   _ pAddress: UnsafeMutablePointer<IP_ADAPTER_UNICAST_ADDRESS>) {
-        self.name = String(decodingCString: pAdapter.pointee.FriendlyName,
-                           as: UTF16.self)
-
-        guard let address = pAddress.pointee.Address.lpSockaddr.convert() else {
-          return nil
-        }
-        self.address = address
-
-        // TODO: convert the prefix length to the mask itself
-        let v4mask: (UINT8) -> SocketAddress? = { _ in
-            var buffer: [CChar] =
-                Array<CChar>(repeating: 0, count: Int(INET_ADDRSTRLEN))
-            var mask: sockaddr_in = sockaddr_in()
-            mask.sin_family = ADDRESS_FAMILY(AF_INET)
-            _ = buffer.withUnsafeMutableBufferPointer {
-                try! NIOBSDSocket.inet_ntop(af: .inet, src: &mask,
-                                            dst: $0.baseAddress!,
-                                            size: INET_ADDRSTRLEN)
-            }
-            return SocketAddress(mask)
-        }
-        let v6mask: (UINT8) -> SocketAddress? = { _ in
-            var buffer: [CChar] =
-                Array<CChar>(repeating: 0, count: Int(INET6_ADDRSTRLEN))
-            var mask: sockaddr_in6 = sockaddr_in6()
-            mask.sin6_family = ADDRESS_FAMILY(AF_INET6)
-            _ = buffer.withUnsafeMutableBufferPointer {
-                try! NIOBSDSocket.inet_ntop(af: .inet6, src: &mask,
-                                            dst: $0.baseAddress!,
-                                            size: INET6_ADDRSTRLEN)
-            }
-            return SocketAddress(mask)
-        }
-
-        switch pAddress.pointee.Address.lpSockaddr.pointee.sa_family {
-        case ADDRESS_FAMILY(AF_INET):
-            self.netmask = v4mask(pAddress.pointee.OnLinkPrefixLength)
-            self.interfaceIndex = Int(pAdapter.pointee.IfIndex)
-        case ADDRESS_FAMILY(AF_INET6):
-            self.netmask = v6mask(pAddress.pointee.OnLinkPrefixLength)
-            self.interfaceIndex = Int(pAdapter.pointee.Ipv6IfIndex)
-        default:
-            return nil
-        }
-
-        // TODO(compnerd) handle broadcast/ppp/multicast information
-        self.broadcastAddress = nil
-        self.pointToPointDestinationAddress = nil
-        self.multicastSupported = false
-    }
-#else
-    internal init?(_ caddr: ifaddrs) {
-        self.name = String(cString: caddr.ifa_name)
-
-        guard caddr.ifa_addr != nil else {
-            return nil
-        }
-
-        guard let address = caddr.ifa_addr!.convert() else {
-            return nil
-        }
-        self.address = address
-
-        if let netmask = caddr.ifa_netmask {
-            self.netmask = netmask.convert()
-        } else {
-            self.netmask = nil
-        }
-
-        if (caddr.ifa_flags & UInt32(IFF_BROADCAST)) != 0, let addr = caddr.broadaddr {
-            self.broadcastAddress = addr.convert()
-            self.pointToPointDestinationAddress = nil
-        } else if (caddr.ifa_flags & UInt32(IFF_POINTOPOINT)) != 0, let addr = caddr.dstaddr {
-            self.broadcastAddress = nil
-            self.pointToPointDestinationAddress = addr.convert()
-        } else {
-            self.broadcastAddress = nil
-            self.pointToPointDestinationAddress = nil
-        }
-
-        if (caddr.ifa_flags & UInt32(IFF_MULTICAST)) != 0 {
-            self.multicastSupported = true
-        } else {
-            self.multicastSupported = false
-        }
-
-        do {
-            self.interfaceIndex = Int(try Posix.if_nametoindex(caddr.ifa_name))
-        } catch {
-            return nil
-        }
-    }
-#endif
-}
-
-@available(*, deprecated, renamed: "NIONetworkDevice")
-extension NIONetworkInterface: CustomDebugStringConvertible {
-    public var debugDescription: String {
-        let baseString = "Interface \(self.name): address \(self.address)"
-        let maskString = self.netmask != nil ? " netmask \(self.netmask!)" : ""
-        return baseString + maskString
-    }
-}
-
-@available(*, deprecated, renamed: "NIONetworkDevice")
-extension NIONetworkInterface: Equatable {
-    public static func ==(lhs: NIONetworkInterface, rhs: NIONetworkInterface) -> Bool {
-        return lhs.name == rhs.name &&
-               lhs.address == rhs.address &&
-               lhs.netmask == rhs.netmask &&
-               lhs.broadcastAddress == rhs.broadcastAddress &&
-               lhs.pointToPointDestinationAddress == rhs.pointToPointDestinationAddress &&
-               lhs.interfaceIndex == rhs.interfaceIndex
-    }
-}

Sources/NIO/SelectableChannel.swift

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 NIOConcurrencyHelpers
+
+/// A `SelectableChannel` is a `Channel` that can be used with a `Selector` which notifies a user when certain events
+/// are possible. On UNIX a `Selector` is usually an abstraction of `select`, `poll`, `epoll` or `kqueue`.
+///
+/// - warning: `SelectableChannel` methods and properties are _not_ thread-safe (unless they also belong to `Channel`).
+internal protocol SelectableChannel: Channel {
+    /// The type of the `Selectable`. A `Selectable` is usually wrapping a file descriptor that can be registered in a
+    /// `Selector`.
+    associatedtype SelectableType: Selectable
+
+    var isOpen: Bool { get }
+
+    /// The event(s) of interest.
+    var interestedEvent: SelectorEventSet { get }
+
+    /// Called when the `SelectableChannel` is ready to be written.
+    func writable()
+
+    /// Called when the `SelectableChannel` is ready to be read.
+    func readable()
+
+    /// Called when the read side of the `SelectableChannel` hit EOF.
+    func readEOF()
+
+    /// Called when the write side of the `SelectableChannel` hit EOF.
+    func writeEOF()
+
+    /// Called when the `SelectableChannel` was reset (ie. is now unusable)
+    func reset()
+
+    func register(selector: Selector<NIORegistration>, interested: SelectorEventSet) throws
+
+    func deregister(selector: Selector<NIORegistration>, mode: CloseMode) throws
+
+    func reregister(selector: Selector<NIORegistration>, interested: SelectorEventSet) throws
+}
+
+/// Multicast is not supported on this interface.
+public struct NIOMulticastNotSupportedError: Error {
+    public var device: NIONetworkDevice
+
+    public init(device: NIONetworkDevice) {
+        self.device = device
+    }
+}
+
+/// Multicast has not been properly implemented on this channel.
+public struct NIOMulticastNotImplementedError: Error {
+    public init() {}
+}

Sources/NIO/SocketChannel.swift

@@ -296,7 +296,7 @@ final class ServerSocketChannel: BaseSocketChannel<ServerSocket> {
     override public func channelRead0(_ data: NIOAny) {
         self.eventLoop.assertInEventLoop()
 
-        let ch = data.forceAsOther() as SocketChannel
+        let ch = self.unwrapData(data, as: SocketChannel.self)
         ch.eventLoop.execute {
             ch.register().flatMapThrowing {
                 guard ch.isOpen else {
@@ -669,7 +669,7 @@ final class DatagramChannel: BaseSocketChannel<Socket> {
     }
     /// Buffer a write in preparation for a flush.
     override func bufferPendingWrite(data: NIOAny, promise: EventLoopPromise<Void>?) {
-        let data = data.forceAsByteEnvelope()
+        let data = self.unwrapData(data, as: AddressedEnvelope<ByteBuffer>.self)
 
         if !self.pendingWrites.add(envelope: data, promise: promise) {
             assert(self.isActive)

Sources/NIO/Utilities.swift

@@ -123,7 +123,7 @@ public enum System {
         }
 
         while let concreteInterface = interface {
-            if let nioInterface = NIONetworkInterface(concreteInterface.pointee) {
+            if let nioInterface = NIONetworkInterface._construct(from: concreteInterface.pointee) {
                 interfaces.append(nioInterface)
             }
             interface = concreteInterface.pointee.ifa_next