Reduce unstructured task (#12)

* Reduce unstructured Task usage

Motivation:
Feedback from @FranzBusch

Modification:
Use lock instead of actor to control access to `ares_channel`.

* Handle task cancellation

Author: yim-lee

Sources/AsyncDNSResolver/c-ares/AresChannel.swift

@@ -13,22 +13,22 @@
 //===----------------------------------------------------------------------===//
 
 import CAsyncDNSResolver
+import Foundation
 
 // MARK: - ares_channel
 
-actor AresChannel {
+class AresChannel {
     let pointer: UnsafeMutablePointer<ares_channel?>
+    let lock = NSLock()
 
     private var underlying: ares_channel? {
         self.pointer.pointee
     }
 
     deinit {
-        Task { [pointer] in
-            ares_destroy(pointer.pointee)
-            pointer.deallocate()
-            ares_library_cleanup()
-        }
+        ares_destroy(pointer.pointee)
+        pointer.deallocate()
+        ares_library_cleanup()
     }
 
     init(options: AresOptions) throws {
@@ -52,6 +52,9 @@ actor AresChannel {
     }
 
     func withChannel(_ body: (ares_channel) -> Void) {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+
         guard let underlying = self.underlying else {
             fatalError("ares_channel not initialized")
         }

Sources/AsyncDNSResolver/c-ares/DNSResolver_c-ares.swift

@@ -141,33 +141,40 @@ class Ares {
         name: String,
         replyParser: ReplyParser
     ) async throws -> ReplyParser.Reply {
-        try await withCheckedThrowingContinuation { continuation in
-            let handler = QueryReplyHandler(parser: replyParser, continuation)
+        try await withTaskCancellationHandler(
+            operation: {
+                try await withCheckedThrowingContinuation { continuation in
+                    let handler = QueryReplyHandler(parser: replyParser, continuation)
+
+                    // Wrap `handler` into a pointer so we can pass it to callback. The pointer will be deallocated in there later.
+                    let handlerPointer = UnsafeMutableRawPointer.allocate(
+                        byteCount: MemoryLayout<QueryReplyHandler>.stride,
+                        alignment: MemoryLayout<QueryReplyHandler>.alignment
+                    )
+                    handlerPointer.initializeMemory(as: QueryReplyHandler.self, repeating: handler, count: 1)
 
-            // Wrap `handler` into a pointer so we can pass it to callback. The pointer will be deallocated in there later.
-            let handlerPointer = UnsafeMutableRawPointer.allocate(
-                byteCount: MemoryLayout<QueryReplyHandler>.stride,
-                alignment: MemoryLayout<QueryReplyHandler>.alignment
-            )
-            handlerPointer.initializeMemory(as: QueryReplyHandler.self, repeating: handler, count: 1)
+                    let queryCallback: QueryCallback = { arg, status, _, buf, len in
+                        guard let handlerPointer = arg else {
+                            preconditionFailure("'arg' is nil. This is a bug.")
+                        }
 
-            let queryCallback: QueryCallback = { arg, status, _, buf, len in
-                guard let handlerPointer = arg else {
-                    preconditionFailure("'arg' is nil. This is a bug.")
-                }
+                        let handler = QueryReplyHandler(pointer: handlerPointer)
+                        defer { handlerPointer.deallocate() }
 
-                let handler = QueryReplyHandler(pointer: handlerPointer)
-                defer { handlerPointer.deallocate() }
-
-                handler.handle(status: status, buffer: buf, length: len)
-            }
+                        handler.handle(status: status, buffer: buf, length: len)
+                    }
 
-            Task {
-                await self.channel.withChannel { channel in
-                    ares_query(channel, name, DNSClass.IN.rawValue, type.intValue, queryCallback, handlerPointer)
+                    self.channel.withChannel { channel in
+                        ares_query(channel, name, DNSClass.IN.rawValue, type.intValue, queryCallback, handlerPointer)
+                    }
+                }
+            },
+            onCancel: {
+                self.channel.withChannel { channel in
+                    ares_cancel(channel)
                 }
             }
-        }
+        )
     }
 
     /// See `arpa/nameser.h`.
@@ -199,7 +206,7 @@ extension Ares {
         func poll() async {
             var socks = [ares_socket_t](repeating: ares_socket_t(), count: Int(ARES_GETSOCK_MAXNUM))
 
-            await self.channel.withChannel { channel in
+            self.channel.withChannel { channel in
                 // Indicates what actions (i.e., read/write) to wait for on the different sockets
                 let bitmask = UInt32(ares_getsock(channel, &socks, ARES_GETSOCK_MAXNUM))
 

Tests/AsyncDNSResolverTests/c-ares/AresChannelTests.swift

@@ -28,7 +28,7 @@ final class AresChannelTests: XCTestCase {
         guard let channel = try? AresChannel(options: options) else {
             return XCTFail("Channel not initialized")
         }
-        guard let _ = await channel.pointer.pointee else {
+        guard let _ = channel.pointer.pointee else {
             return XCTFail("Underlying ares_channel is nil")
         }
     }