BaseStreamSocketChannel half-close allows outstanding writes to complete

Motivation:

At the moment half-closes are actioned immediately and fails all outstanding writes.
We should refuse new writes but allow these writes to complete before
completing the close.

Modifications:

Modify the PendingWritesManager internal buffer to hold an enum of
either writes or close events. We use this to store the close and only
action it when the preceding writes have been handled.

Result:

Outbound close should no longer fail outstanding writes

Author: rnro

Diff for: Sources/NIOPosix/BaseStreamSocketChannel.swift

@@ -194,11 +194,19 @@ class BaseStreamSocketChannel<Socket: SocketProtocol>: BaseSocketChannel<Socket>
                     self.close0(error: error, mode: .all, promise: promise)
                     return
                 }
-                try self.shutdownSocket(mode: mode)
-                // Fail all pending writes and so ensure all pending promises are notified
-                self.pendingWrites.failAll(error: error, close: false)
                 self.unregisterForWritable()
-                promise?.succeed(())
+
+                // Shutdown the socket only when the pending writes are dealt with
+                let closePromise = self.eventLoop.makePromise(of: Void.self)
+                closePromise.futureResult.whenComplete { _ in
+                    do {
+                        try self.shutdownSocket(mode: mode)
+                        promise?.succeed(())
+                    } catch let err {
+                        promise?.fail(err)
+                    }
+                }
+                self.pendingWrites.close(closePromise)
 
                 self.pipeline.fireUserInboundEventTriggered(ChannelEvent.outputClosed)
             case .input:

Diff for: Sources/NIOPosix/PendingDatagramWritesManager.swift

@@ -268,7 +268,8 @@ private struct PendingDatagramWritesState {
         // When we've hit an error we treat it like fully writing the first datagram. We aren't going to try to
         // send it again.
         let promiseFiller = self.wroteFirst(error: error)
-        let result: OneWriteOperationResult = self.pendingWrites.hasMark ? .writtenPartially : .writtenCompletely
+        let result: OneWriteOperationResult =
+            self.pendingWrites.hasMark ? .writtenPartially : .writtenCompletely(closePromise: nil)
 
         return (promiseFiller, result)
     }
@@ -305,7 +306,8 @@ private struct PendingDatagramWritesState {
         }
 
         // If we no longer have a mark, we wrote everything.
-        let result: OneWriteOperationResult = self.pendingWrites.hasMark ? .writtenPartially : .writtenCompletely
+        let result: OneWriteOperationResult =
+            self.pendingWrites.hasMark ? .writtenPartially : .writtenCompletely(closePromise: nil)
         return (promiseFiller, result)
     }
 
@@ -322,7 +324,8 @@ private struct PendingDatagramWritesState {
         )
         let writeFiller = self.wroteFirst()
         // If we no longer have a mark, we wrote everything.
-        let result: OneWriteOperationResult = self.pendingWrites.hasMark ? .writtenPartially : .writtenCompletely
+        let result: OneWriteOperationResult =
+            self.pendingWrites.hasMark ? .writtenPartially : .writtenCompletely(closePromise: nil)
         return (writeFiller, result)
     }
 
@@ -565,7 +568,7 @@ final class PendingDatagramWritesManager: PendingWritesManager {
                 preconditionFailure("PendingDatagramWritesManager was handed a file write")
             case .nothingToBeWritten:
                 assertionFailure("called \(#function) with nothing available to be written")
-                return OneWriteOperationResult.writtenCompletely
+                return OneWriteOperationResult.writtenCompletely(closePromise: nil)
             }
         }
     }