From f845b5c44f75757296e0d0821e65f516cd5d59dc Mon Sep 17 00:00:00 2001 From: wallentx Date: Sun, 25 Oct 2026 21:23:17 -0500 Subject: [PATCH] Keep failed session artifact collections incomplete --- .../launcher/session/SessionArtifacts.kt | 50 +++++++++++++++---- .../launcher/session/SessionLogShareTest.kt | 34 +++++++++++++ .../launcher/session/SessionSteamLogsTest.kt | 35 +++++++++++++ 3 files changed, 108 insertions(+), 11 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionArtifacts.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionArtifacts.kt index ea87a30706..b4408c48b9 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionArtifacts.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionArtifacts.kt @@ -7,6 +7,9 @@ import com.droiddeck.launcher.core.SessionLogCapture import com.droiddeck.launcher.runtime.LinuxRuntime import com.droiddeck.launcher.wayland.WaylandCompositor import java.io.File +import java.io.Writer +import java.nio.file.Files +import java.nio.file.StandardCopyOption import java.text.SimpleDateFormat import java.util.Date import java.util.Locale @@ -75,9 +78,9 @@ object SessionArtifacts { copySteamLogs(context, dir, record, steamArch) VacDiagnostics.collect(context, dir) SessionLogCapture.dumpCrashBuffer(File(dir, "crash.log")) - markScrubbed(scrubTree(record)) + val scrubbed = markScrubbed(scrubTree(record)) SessionEvents.record("session.artifacts_collected", mapOf("reason" to reason), dir) - File(dir, COMPLETE_MARKER).writeText("collected: $reason at ${now()}\n") + if (scrubbed) File(dir, COMPLETE_MARKER).writeText("collected: $reason at ${now()}\n") } catch (e: Exception) { Log.w(TAG, "collecting session artifacts", e) } @@ -126,8 +129,13 @@ object SessionArtifacts { record: Record, shouldStop: () -> Boolean, beforeReplace: (File) -> Unit, + listFiles: (File) -> Array?, ): Boolean { - val files = dir.listFiles { f -> f.isFile && !f.name.startsWith(".") && f !in record.files } ?: return true + val files = listFiles(dir)?.filter { f -> f.isFile && !f.name.startsWith(".") && f !in record.files } + if (files == null) { + record.failed = true + return true + } for (f in files) { if (shouldStop()) return false if (LogRedactor.isBinary(f)) continue @@ -266,10 +274,16 @@ object SessionArtifacts { dir: File, stopWhenSessionStarts: Boolean = false, beforeReplace: (File) -> Unit = {}, + listFiles: (File) -> Array? = { it.listFiles() }, sessionStarted: () -> Boolean = { SessionState.running }, ): Boolean { val shouldStop = { stopWhenSessionStarts && sessionStarted() } - val record = scrubTree(Record(dir), shouldStop, beforeReplace) + val record = scrubTree( + Record(dir), + listFiles = listFiles, + beforeReplace = beforeReplace, + shouldStop = shouldStop, + ) if (shouldStop()) { record.failed = true record.deferred = true @@ -279,11 +293,12 @@ object SessionArtifacts { private fun scrubTree( record: Record, - shouldStop: () -> Boolean = { false }, + listFiles: (File) -> Array? = { it.listFiles() }, beforeReplace: (File) -> Unit = {}, + shouldStop: () -> Boolean = { false }, ): Record { for (dir in record.dir.walkTopDown().filter { it.isDirectory }) { - if (shouldStop() || !scrubFolder(dir, record, shouldStop, beforeReplace)) { + if (shouldStop() || !scrubFolder(dir, record, shouldStop, beforeReplace, listFiles)) { record.failed = true record.deferred = true break @@ -364,13 +379,18 @@ object SessionArtifacts { Log.i(TAG, "collected ${out.listFiles()?.size ?: 0} Steam log(s), scrubbed, into $out") } - internal fun copySessionLogs(logs: File, dir: File, out: File): List = - copySessionLogsResult(logs, dir, out) { false }.files + internal fun copySessionLogs( + logs: File, + dir: File, + out: File, + openWriter: (File) -> Writer = { it.bufferedWriter() }, + ): List = copySessionLogsResult(logs, dir, out, openWriter) { false }.files private fun copySessionLogsResult( logs: File, dir: File, out: File, + openWriter: (File) -> Writer = { it.bufferedWriter() }, shouldStop: () -> Boolean, ): CopyResult { val marks = steamLogMarks(dir) @@ -387,8 +407,9 @@ object SessionArtifacts { val size = src.length() val from = marks?.let { startOf(src, size, it) } ?: 0L if (marks != null && from == size || size - from >= MAX_STEAM_LOG) continue + val dst = File(out, src.name) + val staging = File(out, ".${src.name}.copy") try { - val dst = File(out, src.name) src.inputStream().buffered().use { input -> var left = if (from > 0) from - 1 else 0L while (left > 0) { @@ -402,16 +423,23 @@ object SessionArtifacts { if (c < 0 || c == '\n'.code) break } } - val complete = dst.bufferedWriter().use { w -> scrubSteamLog(input, w, shouldStop) } + val complete = openWriter(staging).use { w -> scrubSteamLog(input, w, shouldStop) } if (!complete) { - dst.delete() + staging.delete() failed = true deferred = true } } if (deferred) break + Files.move( + staging.toPath(), + dst.toPath(), + StandardCopyOption.ATOMIC_MOVE, + StandardCopyOption.REPLACE_EXISTING, + ) copied += dst } catch (e: Exception) { + staging.delete() Log.w(TAG, "could not scrub ${src.name}", e) failed = true } diff --git a/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareTest.kt index f7de6d27ee..fc42592057 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareTest.kt @@ -152,6 +152,40 @@ class SessionLogShareTest { assertTrue(zip(folder).values.none { it.contains(leaked) }) } + @Test fun aDirectoryListingFailureLeavesTheTreeUnrecordedButDoesNotStopSiblingScrubbing() { + val folder = tmp.newFolder("2026-10-06-06-listing") + val unavailable = File(folder, "unavailable").apply { mkdirs() } + val unavailableLog = File(unavailable, "session.log").apply { writeText("$secret\n") } + val availableLog = File(folder, "available/session.log").apply { + parentFile!!.mkdirs() + writeText("$secret\n") + } + + assertFalse(SessionArtifacts.scrubAndMark(folder, listFiles = { + if (it == unavailable) null else it.listFiles() + })) + + assertTrue(unavailableLog.readText().contains(leaked)) + assertFalse(availableLog.readText().contains(leaked)) + assertFalse(File(folder, ".scrubbed-r${LogRedactor.RULES_VERSION}").exists()) + assertFalse(File(folder, SessionArtifacts.SCRUBBED_TREE_MARKER).exists()) + } + + @Test fun aFailedScrubStillRecordsTheCollectionEventWithoutCompletingTheFolder() { + val context: android.content.Context = RuntimeEnvironment.getApplication() + val folder = tmp.newFolder("2026-10-06-06-collect") + File(folder, SessionArtifacts.SCRUBBED_TREE_MARKER).apply { + mkdirs() + resolve("blocker").writeText("force marker write failure\n") + } + + SessionArtifacts.collect(context, folder, "test") + + assertTrue(File(folder, "events.jsonl").readText().contains("session.artifacts_collected")) + assertFalse(File(folder, SessionArtifacts.COMPLETE_MARKER).exists()) + assertFalse(File(folder, ".scrubbed-r${LogRedactor.RULES_VERSION}").exists()) + } + @Test fun steamLogsPastTheSizeLimitStayOut() { val folder = tmp.newFolder("2026-10-06-07-steam") File(folder, "session.log").writeText("ok\n") diff --git a/app/src/test/java/com/droiddeck/launcher/session/SessionSteamLogsTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SessionSteamLogsTest.kt index 60c57ecfd5..73847dc534 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SessionSteamLogsTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SessionSteamLogsTest.kt @@ -6,6 +6,8 @@ import org.junit.Rule import org.junit.Test import org.junit.rules.TemporaryFolder import java.io.File +import java.io.IOException +import java.io.Writer class SessionSteamLogsTest { @get:Rule val tmp = TemporaryFolder() @@ -59,4 +61,37 @@ class SessionSteamLogsTest { assertEquals(listOf("web.txt"), names(copied)) assertFalse(File(out, "web.txt").readText().contains("abcdef123456")) } + + @Test fun aCopyFailurePreservesThePreviousSnapshotAndRemovesPartialStaging() { + val logs = tmp.newFolder("logs") + val session = tmp.newFolder("session") + val out = tmp.newFolder("out") + File(logs, "console_log.txt").writeText("new complete line\n") + val snapshot = File(out, "console_log.txt").apply { writeText("previous valid snapshot\n") } + lateinit var staging: File + + val copied = SessionArtifacts.copySessionLogs(logs, session, out) { target -> + staging = target + val delegate = target.bufferedWriter() + object : Writer() { + private var failed = false + + override fun write(buffer: CharArray, offset: Int, length: Int) { + if (!failed) { + delegate.write(buffer, offset, minOf(length, 4)) + delegate.flush() + failed = true + } + throw IOException("injected writer failure") + } + + override fun flush() = delegate.flush() + override fun close() = delegate.close() + } + } + + assertTrue(copied.isEmpty()) + assertEquals("previous valid snapshot\n", snapshot.readText()) + assertFalse(staging.exists()) + } }