Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.
Swift cache-cleanercleanerclideveloper-toolsdisk-cleanupdisk-spaceduplicate-finderhomebrewliquid-glassmac-cleanermacosmacos-appmacos-golden-gatemacos-tahoemacos-tweaksswiftswiftuiterminal-themesuninstalluninstaller
The folder watch's stream keeps its listener until a running call ends
Țugui Dragoș87ba4413aa3e
diff --git a/Packages/PeelCore/Sources/PeelCore/Apps/FolderWatch.swift b/Packages/PeelCore/Sources/PeelCore/Apps/FolderWatch.swiftindex 50f6d3b5..d9cfc6ad 100644--- a/Packages/PeelCore/Sources/PeelCore/Apps/FolderWatch.swift+++ b/Packages/PeelCore/Sources/PeelCore/Apps/FolderWatch.swift@@ -25,26 +25,28 @@ public enum FolderWatch {orEvery interval: TimeInterval) -> AsyncStream<Void> {AsyncStream(bufferingPolicy: .bufferingNewest(1)) { continuation in- let listener = Unmanaged.passRetained(Listener(continuation))- var context = FSEventStreamContext(version: 0, info: listener.toOpaque(), retain: nil, release: nil, copyDescription: nil)+ let listener = Listener(continuation)+ var context = Self.context(owning: listener)let paths = folders.map { $0.path(percentEncoded: false) } as CFArray- guard let stream = FSEventStreamCreate(- nil,- { _, info, _, _, _, _ in- guard let info else { return }- Unmanaged<Listener>.fromOpaque(info).takeUnretainedValue().continuation.yield()- },- &context,- paths,- FSEventStreamEventId(kFSEventStreamEventIdSinceNow),- latency,- FSEventStreamCreateFlags(kFSEventStreamCreateFlagWatchRoot)- ) else {- listener.release()+ let created = withExtendedLifetime(listener) {+ FSEventStreamCreate(+ nil,+ { _, info, _, _, _, _ in+ guard let info else { return }+ Unmanaged<Listener>.fromOpaque(info).takeUnretainedValue().continuation.yield()+ },+ &context,+ paths,+ FSEventStreamEventId(kFSEventStreamEventIdSinceNow),+ latency,+ FSEventStreamCreateFlags(kFSEventStreamCreateFlagWatchRoot)+ )+ }+ guard let stream = created else {lookAgain(every: interval, continuation)return}- let watch = Watch(stream: stream, listener: listener)+ let watch = Watch(stream: stream)FSEventStreamSetDispatchQueue(stream, DispatchQueue.global(qos: .utility))guard start(stream) else {watch.end()@@ -56,6 +58,26 @@ public enum FolderWatch {}}+ /// A context through which the stream keeps `info` until the stream is deallocated. Stopping, invalidating and+ /// releasing a stream wait for no callback, while the stream itself lives until a callback already running+ /// returns, so what the callback uses must go with the stream and not before.+ static func context(owning info: AnyObject) -> FSEventStreamContext {+ FSEventStreamContext(+ version: 0,+ info: Unmanaged.passUnretained(info).toOpaque(),+ retain: { info in+ guard let info else { return nil }+ _ = Unmanaged<AnyObject>.fromOpaque(info).retain()+ return info+ },+ release: { info in+ guard let info else { return }+ Unmanaged<AnyObject>.fromOpaque(info).release()+ },+ copyDescription: nil+ )+ }+private static func lookAgain(every interval: TimeInterval, _ continuation: AsyncStream<Void>.Continuation) {let timer = DispatchSource.makeTimerSource(queue: DispatchQueue.global(qos: .utility))timer.schedule(deadline: .now() + interval, repeating: interval)@@ -72,16 +94,14 @@ public enum FolderWatch {}}- /// Owns the event stream and the listener its callback uses. `end()` stops and releases both, and must run- /// exactly once. Only a stream that started is stopped, as `FSEventStreamStop` requires.+ /// Owns the event stream. `end()` stops and releases it, and must run exactly once. Only a stream that started+ /// is stopped, as `FSEventStreamStop` requires.private final class Watch: @unchecked Sendable {private let stream: FSEventStreamRef- private let listener: Unmanaged<Listener>var isStarted = false- init(stream: FSEventStreamRef, listener: Unmanaged<Listener>) {+ init(stream: FSEventStreamRef) {self.stream = stream- self.listener = listener}func end() {@@ -90,7 +110,6 @@ public enum FolderWatch {}FSEventStreamInvalidate(stream)FSEventStreamRelease(stream)- listener.release()}}}diff --git a/Packages/PeelCore/Tests/PeelCoreTests/FolderWatchTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/FolderWatchTests.swiftindex df495f21..36f0110c 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/FolderWatchTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/FolderWatchTests.swift@@ -1,5 +1,7 @@+import CoreServicesimport Foundation@testable import PeelCore+import Synchronizationimport Testingstruct FolderWatchTests {@@ -77,6 +79,59 @@ struct FolderWatchTests {#expect(await iterator.next() != nil, "it looked again only once")}+ private static let callback = Atomic<Int>(0)+ private static let listenerIsGone = Atomic<Bool>(false)++ private final class Listener {+ deinit { FolderWatchTests.listenerIsGone.store(true, ordering: .sequentiallyConsistent) }+ }++ @Test func whatTheCallbackUsesLastsUntilARunningCallbackReturns() throws {+ Self.callback.store(0, ordering: .sequentiallyConsistent)+ Self.listenerIsGone.store(false, ordering: .sequentiallyConsistent)+ let directory = try TemporaryDirectory()+ var created: FSEventStreamRef?+ do {+ let listener = Listener()+ var context = FolderWatch.context(owning: listener)+ created = withExtendedLifetime(listener) {+ FSEventStreamCreate(+ nil,+ { _, _, _, _, _, _ in+ FolderWatchTests.callback.store(1, ordering: .sequentiallyConsistent)+ Thread.sleep(forTimeInterval: 0.3)+ FolderWatchTests.callback.store(2, ordering: .sequentiallyConsistent)+ },+ &context,+ [directory.url.path(percentEncoded: false)] as CFArray,+ FSEventStreamEventId(kFSEventStreamEventIdSinceNow),+ 0.05,+ FSEventStreamCreateFlags(kFSEventStreamCreateFlagWatchRoot)+ )+ }+ }+ let stream = try #require(created)+ FSEventStreamSetDispatchQueue(stream, DispatchQueue.global(qos: .utility))+ try #require(FSEventStreamStart(stream))+ _ = try directory.file("change.txt")+ let deadline = ContinuousClock.now + Self.patience+ while Self.callback.load(ordering: .sequentiallyConsistent) == 0, .now < deadline { usleep(1_000) }+ let running = Self.callback.load(ordering: .sequentiallyConsistent)+ try #require(running == 1, "no callback came")++ FSEventStreamStop(stream)+ FSEventStreamInvalidate(stream)+ FSEventStreamRelease(stream)++ let goneWhileRunning = Self.listenerIsGone.load(ordering: .sequentiallyConsistent)+ #expect(!goneWhileRunning, "it went while the callback was running")+ while !Self.listenerIsGone.load(ordering: .sequentiallyConsistent), .now < deadline { usleep(1_000) }+ let callback = Self.callback.load(ordering: .sequentiallyConsistent)+ let gone = Self.listenerIsGone.load(ordering: .sequentiallyConsistent)+ #expect(callback == 2)+ #expect(gone, "the stream never let it go")+ }+private func firstChange(of changes: AsyncStream<Void>, within limit: Duration) async -> Bool {await withTaskGroup(of: Bool.self) { group ingroup.addTask {