Skip to content

armgit / peel

Public Imported from GitHub
0

Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.

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.swift
index 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.swift
index df495f21..36f0110c 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/FolderWatchTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/FolderWatchTests.swift
@@ -1,5 +1,7 @@
+import CoreServices
import Foundation
@testable import PeelCore
+import Synchronization
import Testing
struct 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 in
group.addTask {