Move to polling based directory check

Author: JaewonHur

Sources/DNSServer/DirectoryWatcher.swift

@@ -22,7 +22,7 @@ import Logging
 /// Watches a directory for changes and invokes a handler when the contents change.
 ///
 /// `DirectoryWatcher` uses `DispatchSource` file system events to monitor a directory.
-/// If the target directory does not exist yet, it watches the parent directory until
+/// If the target directory does not exist yet, it polls until the directory is created.
 /// the target is created, then transitions to watching the target directly.
 ///
 /// Example usage:
@@ -32,12 +32,14 @@ import Logging
 ///     print("Directory contents changed: \(urls)")
 /// }
 /// ```
-public class DirectoryWatcher {
+public actor DirectoryWatcher {
+    public static let watchPeriod = Duration.seconds(1)
+
     /// The URL of the directory being watched.
     public let directoryURL: URL
 
+    private var task: Task<Void, any Error>?
     private let monitorQueue: DispatchQueue
-    private var parentSource: DispatchSourceFileSystemObject?
     private var source: DispatchSourceFileSystemObject?
 
     private let log: Logger?
@@ -53,6 +55,24 @@ public class DirectoryWatcher {
         self.log = log
     }
 
+    /// Starts watching the directory for changes.
+    ///
+    /// - Parameters:
+    ///   - handler: handler to run on directory state change.
+    public func startWatching(handler: @Sendable @escaping ([URL]) throws -> Void) throws {
+        self.task = Task {
+            var pollDirectory = true
+            while pollDirectory {
+                if self.directoryURL.isDirectory {
+                    try _startWatching(handler: handler)
+
+                    pollDirectory = false
+                    try await Task.sleep(for: Self.watchPeriod)
+                }
+            }
+        }
+    }
+
     private func _startWatching(
         handler: @escaping ([URL]) throws -> Void
     ) throws {
@@ -95,57 +115,8 @@ public class DirectoryWatcher {
         dispatchSource.resume()
     }
 
-    /// Starts watching the directory for changes.
-    public func startWatching(handler: @escaping ([URL]) throws -> Void) throws {
-        guard source == nil else {
-            throw ContainerizationError(.invalidState, message: "already watching on \(directoryURL.path)")
-        }
-
-        let parent = directoryURL.deletingLastPathComponent().resolvingSymlinksInPathWithPrivate()
-        guard parent.isDirectory else {
-            throw ContainerizationError(.invalidState, message: "expected \(parent.path) to be an existing directory")
-        }
-
-        guard !directoryURL.isSymlink else {
-            throw ContainerizationError(.invalidState, message: "expected \(directoryURL.path) not a symlink")
-        }
-
-        guard directoryURL.isDirectory else {
-            log?.info("no target directory, start watching parent", metadata: ["path": "\(parent.path)"])
-
-            let descriptor = open(parent.path, O_EVTONLY)
-            let source = DispatchSource.makeFileSystemObjectSource(
-                fileDescriptor: descriptor,
-                eventMask: .write,
-                queue: monitorQueue)
-
-            source.setCancelHandler {
-                close(descriptor)
-            }
-
-            source.setEventHandler { [weak self] in
-                guard let self else { return }
-
-                if directoryURL.isDirectory {
-                    do {
-                        try _startWatching(handler: handler)
-                    } catch {
-                        log?.error("failed to start watching", metadata: ["error": "\(error)"])
-                    }
-                    source.cancel()
-                }
-            }
-
-            parentSource = source
-            source.resume()
-            return
-        }
-
-        try _startWatching(handler: handler)
-    }
-
     deinit {
-        parentSource?.cancel()
+        self.task?.cancel()
         source?.cancel()
     }
 }

Sources/Helpers/APIServer/APIServer+Start.swift

@@ -123,7 +123,7 @@ extension APIServer {
                     group.addTask {
                         do {
                             let localhostResolver = LocalhostDNSHandler(log: log)
-                            try localhostResolver.monitorResolvers()
+                            try await localhostResolver.monitorResolvers()
 
                             let nxDomainResolver = NxDomainResolver()
                             let compositeResolver = CompositeResolver(handlers: [localhostResolver, nxDomainResolver])

Sources/Helpers/APIServer/LocalhostDNSHandler.swift

@@ -22,11 +22,11 @@ import DNSServer
 import Foundation
 import Logging
 
-class LocalhostDNSHandler: DNSHandler {
+actor LocalhostDNSHandler: DNSHandler {
     private let ttl: UInt32
     private let watcher: DirectoryWatcher
 
-    private var dns: [String: IPv4]
+    nonisolated(unsafe) private var dns: [String: IPv4]
 
     public init(resolversURL: URL = HostDNSResolver.defaultConfigPath, ttl: UInt32 = 5, log: Logger) {
         self.ttl = ttl
@@ -35,8 +35,8 @@ class LocalhostDNSHandler: DNSHandler {
         self.dns = [:]
     }
 
-    public func monitorResolvers() throws {
-        try self.watcher.startWatching { fileURLs in
+    public func monitorResolvers() async throws {
+        try await self.watcher.startWatching { fileURLs in
             var dns: [String: IPv4] = [:]
             let regex = try Regex(HostDNSResolver.localhostOptionsRegex)
 
@@ -54,7 +54,7 @@ class LocalhostDNSHandler: DNSHandler {
         }
     }
 
-    public func answer(query: Message) async throws -> Message? {
+    nonisolated public func answer(query: Message) async throws -> Message? {
         let question = query.questions[0]
         var record: ResourceRecord?
         switch question.type {

Tests/DNSServerTests/DirectoryWatcherTest.swift

@@ -41,16 +41,12 @@ struct DirectoryWatcherTest {
         return try await body(tempDir)
     }
 
-    private class CreatedURLs {
-        public var urls: [URL]
+    private actor CreatedURLs {
+        nonisolated(unsafe) public var urls: [URL]
 
         public init() {
             self.urls = []
         }
-
-        public func append(url: URL) {
-            urls.append(url)
-        }
     }
 
     @Test func testWatchingExistingDirectory() async throws {
@@ -60,18 +56,16 @@ struct DirectoryWatcherTest {
             let createdURLs = CreatedURLs()
             let name = "newFile"
 
-            #expect(throws: Never.self) {
-                try watcher.startWatching { [createdURLs] urls in
-                    for url in urls where url.lastPathComponent == name {
-                        createdURLs.append(url: url)
-                    }
+            try await watcher.startWatching { [createdURLs] urls in
+                for url in urls where url.lastPathComponent == name {
+                    createdURLs.urls.append(url)
                 }
             }
 
-            try await Task.sleep(for: .milliseconds(500))
+            try await Task.sleep(for: .milliseconds(100))
             let newFile = tempDir.appendingPathComponent(name)
             FileManager.default.createFile(atPath: newFile.path, contents: nil)
-            try await Task.sleep(for: .milliseconds(500))
+            try await Task.sleep(for: .milliseconds(100))
 
             #expect(!createdURLs.urls.isEmpty, "directory watcher failed to detect new file")
             #expect(createdURLs.urls.first!.lastPathComponent == name)
@@ -87,75 +81,53 @@ struct DirectoryWatcherTest {
             let createdURLs = CreatedURLs()
             let name = "newFile"
 
-            #expect(throws: Never.self) {
-                try watcher.startWatching { [createdURLs] urls in
-                    for url in urls where url.lastPathComponent == name {
-                        createdURLs.append(url: url)
-                    }
+            try await watcher.startWatching { [createdURLs] urls in
+                for url in urls where url.lastPathComponent == name {
+                    createdURLs.urls.append(url)
                 }
             }
 
-            try await Task.sleep(for: .milliseconds(300))
+            try await Task.sleep(for: .milliseconds(100))
             try FileManager.default.createDirectory(at: childDir, withIntermediateDirectories: true)
 
-            try await Task.sleep(for: .milliseconds(300))
+            try await Task.sleep(for: DirectoryWatcher.watchPeriod)
             let newFile = childDir.appendingPathComponent(name)
             FileManager.default.createFile(atPath: newFile.path, contents: nil)
-            try await Task.sleep(for: .milliseconds(300))
+            try await Task.sleep(for: .milliseconds(100))
 
             #expect(!createdURLs.urls.isEmpty, "directory watcher failed to detect parent directory")
             #expect(createdURLs.urls.first!.lastPathComponent == name)
-
         }
+    }
 
+    @Test func testWatchingNonExistingParent() async throws {
         try await withTempDir { tempDir in
             let parent = UUID().uuidString
-            let symlink = UUID().uuidString
             let child = UUID().uuidString
-
-            let parentDir = tempDir.appendingPathComponent(parent)
-            let symlinkDir = tempDir.appendingPathComponent(symlink)
-            let childDir = symlinkDir.appendingPathComponent(child)
-
-            try FileManager.default.createDirectory(at: parentDir, withIntermediateDirectories: true)
-            try FileManager.default.createSymbolicLink(at: symlinkDir, withDestinationURL: parentDir)
+            let childDir = tempDir.appendingPathComponent(parent).appendingPathComponent(child)
 
             let watcher = DirectoryWatcher(directoryURL: childDir, log: nil)
             let createdURLs = CreatedURLs()
             let name = "newFile"
 
-            #expect(throws: Never.self) {
-                try watcher.startWatching { [createdURLs] urls in
-                    for url in urls where url.lastPathComponent == name {
-                        createdURLs.append(url: url)
-                    }
+            try await watcher.startWatching { urls in
+                for url in urls where url.lastPathComponent == name {
+                    createdURLs.urls.append(url)
                 }
             }
 
-            try await Task.sleep(for: .milliseconds(300))
+            try await Task.sleep(for: .microseconds(100))
             try FileManager.default.createDirectory(at: childDir, withIntermediateDirectories: true)
 
-            try await Task.sleep(for: .milliseconds(300))
+            try await Task.sleep(for: DirectoryWatcher.watchPeriod)
+
             let newFile = childDir.appendingPathComponent(name)
             FileManager.default.createFile(atPath: newFile.path, contents: nil)
-            try await Task.sleep(for: .milliseconds(300))
+            try await Task.sleep(for: .milliseconds(100))
 
-            #expect(!createdURLs.urls.isEmpty, "directory watcher failed to detect symbolic parent directory")
+            #expect(!createdURLs.urls.isEmpty, "directory watcher failed to detect parent directory")
             #expect(createdURLs.urls.first!.lastPathComponent == name)
         }
     }
 
-    @Test func testWatchingNonExistingParent() async throws {
-        try await withTempDir { tempDir in
-            let parent = UUID().uuidString
-            let child = UUID().uuidString
-            let childDir = tempDir.appendingPathComponent(parent).appendingPathComponent(child)
-
-            let watcher = DirectoryWatcher(directoryURL: childDir, log: nil)
-            #expect(throws: ContainerizationError.self, "directory watcher should fail if no parent") {
-                try watcher.startWatching { urls in }
-            }
-        }
-    }
-
 }