fix(#516): review round 5 - hash bound to the copy's name, folder untouched when nothing moved, re-arm under the reconcile lock

This commit is contained in:
makiolaj committed 2026-11-14 12:03:23 +01:00
1 parent 6758b7fada
commit 34cd75e9a3
4 files changed
+83 -51

No files matched your search

@@ -31,10 +31,12 @@ import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
import de.jeanlucmakiola.calendula.data.ics.IcsExporter
import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.calendula.domain.backup.BackupFilePlan
import de.jeanlucmakiola.calendula.domain.backup.BackupTarget
import de.jeanlucmakiola.calendula.domain.backup.backupFingerprint
import de.jeanlucmakiola.calendula.domain.backup.backupTargets
import de.jeanlucmakiola.calendula.domain.backup.inBackupOrder
import de.jeanlucmakiola.calendula.domain.backup.latestHeldElsewhere
import de.jeanlucmakiola.calendula.domain.backup.latestFileName
import de.jeanlucmakiola.calendula.domain.backup.latestLedgerKey
import de.jeanlucmakiola.calendula.domain.backup.needsRefresh
import de.jeanlucmakiola.calendula.domain.backup.planBackupFiles
@@ -106,7 +108,7 @@ object BackupScheduler {
ExistingPeriodicWorkPolicy.UPDATE,
request,
)
if (!prefs.autoBackupOnChange.first()) {
if (!watchWanted(prefs)) {
cancelWatch()
return@withLock
}
@@ -117,6 +119,14 @@ object BackupScheduler {
}
}
/** Arm [slot] for a running change run, under the same lock as [reconcile] so it can't outlast a switch-off. */
internal suspend fun watchNext(context: Context, prefs: SettingsPrefs, slot: Int) = withContext(NonCancellable) {
reconcileLock.withLock { if (watchWanted(prefs)) watchChanges(context, slot) }
}
private suspend fun watchWanted(prefs: SettingsPrefs): Boolean =
prefs.autoBackupEnabled.first() && prefs.autoBackupFolderUri.first() != null && prefs.autoBackupOnChange.first()
/**
* Run one export immediately (e.g. right after enabling or changing the
* folder) for instant feedback. Unique + REPLACE so rapid taps coalesce into
@@ -181,11 +191,7 @@ class BackupWorker(
val prefs = deps.settingsPrefs()
val slot = inputData.getInt(BackupScheduler.KEY_CHANGE_SLOT, -1)
if (slot < 0) return backUp(deps, prefs, changeRun = false)
suspend fun watchNext() {
val wanted = prefs.autoBackupEnabled.first() && prefs.autoBackupOnChange.first() &&
prefs.autoBackupFolderUri.first() != null
if (wanted) BackupScheduler.watchChanges(applicationContext, slot = 1 - slot)
}
suspend fun watchNext() = BackupScheduler.watchNext(applicationContext, prefs, slot = 1 - slot)
runCatching { watchNext() }.onFailure { Log.w(TAG, "Arming the next change run failed", it) }
// Never fails or retries: a retry would only wait for another change.
try {
@@ -195,7 +201,7 @@ class BackupWorker(
} catch (e: Exception) {
Log.w(TAG, "Backup after a change failed", e)
} finally {
withContext(NonCancellable) { runCatching { watchNext() } }
runCatching { watchNext() }
}
return Result.success()
}
@@ -208,10 +214,7 @@ class BackupWorker(
*/
private suspend fun backUp(deps: Deps, prefs: SettingsPrefs, changeRun: Boolean): Result {
val now = System.currentTimeMillis()
// The periodic, the immediate and the change runs are separate unique
// works; one at a time, or each would overwrite the other's ledger.
// The record is made under the lock too, so each streak reaches the
// threshold in exactly one run.
// One run at a time, or each would overwrite the other's ledger.
var failures = 0
val outcome = runLock.withLock {
// Respect the toggles even for already-queued work, so a lingering
@@ -228,8 +231,10 @@ class BackupWorker(
RunOutcome.Failed
}
if (outcome != RunOutcome.NothingToDo) {
prefs.recordAutoBackupRun(success = outcome == RunOutcome.Written, atMillis = now)
failures = prefs.autoBackupStatus.first().consecutiveFailures
withContext(NonCancellable) {
prefs.recordAutoBackupRun(success = outcome == RunOutcome.Written, atMillis = now)
failures = prefs.autoBackupStatus.first().consecutiveFailures
}
}
outcome
}
@@ -243,8 +248,8 @@ class BackupWorker(
private enum class RunOutcome { Written, PartlyFailed, Failed, NothingToDo }
/** A stable copy's write: whether it [landed] under its own name, or [failed] before it was written. */
private data class LatestWrite(val landed: Boolean, val failed: Boolean)
/** How a stable copy's write went: under its own name, under one the provider picked, or not at all. */
private enum class LatestWrite { Landed, Renamed, Failed }
/**
* Writes each series and prunes it only once its new file has landed. A
@@ -259,10 +264,31 @@ class BackupWorker(
val selection = prefs.autoBackupSelection.first()
val targets = backupTargets(all.filter(selection::selects), combined = prefs.autoBackupCombined.first())
if (targets.isEmpty()) return RunOutcome.NothingToDo
val stamp = Clock.System.now()
val fingerprints = prefs.autoBackupFingerprints.first()
suspend fun export(target: BackupTarget): String? = try {
val events = repository.exportEvents(target.calendarIds).inBackupOrder()
IcsWriter().writeCalendar(events, stamp, target.calendarName)
} catch (e: CancellationException) {
throw e
} catch (e: Exception) {
Log.w(TAG, "Reading one series failed", e)
null
}
fun fingerprintOf(target: BackupTarget, text: String) =
backupFingerprint(text, latestFileName(target.baseName))
// A change run reads first and leaves the folder alone when nothing moved.
val texts = HashMap<String, String?>()
if (latestOnly) {
targets.forEach { texts[it.key] = export(it) }
val unchanged = targets.all { target ->
texts[target.key]?.let { fingerprintOf(target, it) }.let { it != null && it == fingerprints[target.key] }
}
if (unchanged) return RunOutcome.NothingToDo
}
prefs.adoptLegacyBackupFile()
val listing = exporter.listFolder(folder)
val ledger = prefs.autoBackupLedger.first()
val fingerprints = prefs.autoBackupFingerprints.first()
// A listing still loading can't tell a gone file from a late one.
val existing = if (listing.complete) listing.files.keys else listing.files.keys + ledger.values.flatten()
val plans = planBackupFiles(
@@ -272,7 +298,6 @@ class BackupWorker(
at = LocalDateTime.now(),
keep = prefs.autoBackupKeep.first(),
)
val stamp = Clock.System.now()
val liveKeys = all.map { it.id.toString() }.toSet()
suspend fun record(key: String, files: List<String>) =
prefs.updateAutoBackupLedger(folder.toString()) { withLedgerEntry(it, key, files, liveKeys) }
@@ -288,15 +313,13 @@ class BackupWorker(
false
}
// An old copy goes only once the new one has landed, so a series is
// never left without one.
// An old copy goes only once the new one has landed.
suspend fun writeLatest(plan: BackupFilePlan, bytes: ByteArray, fingerprint: String): LatestWrite {
val target = plan.target
val latest = checkNotNull(plan.latestName)
var landed: String? = null
return try {
val latestKey = latestLedgerKey(target.key)
// A write cut short leaves a partial copy that must not pass as current.
if (target.key in fingerprints) prefs.dropAutoBackupFingerprint(folder.toString(), target.key)
landed = exporter.writeToFolder(folder, listing, latest, bytes)
// A provider that renamed it leaves a copy to clean up next
@@ -317,10 +340,14 @@ class BackupWorker(
recordLatest(plan.staleLatest, fingerprint.takeIf { landed == latest })
val staleLeft = exporter.deleteFromFolder(listing, plan.staleLatest)
recordLatest(plan.staleLatest.filter { it in staleLeft })
LatestWrite(landed = landed == latest, failed = false)
if (landed == latest) LatestWrite.Landed else LatestWrite.Renamed
} catch (e: Exception) {
Log.w(TAG, "Stable copy of one series failed", e)
LatestWrite(landed = landed == latest, failed = landed == null)
when (landed) {
null -> LatestWrite.Failed
latest -> LatestWrite.Landed
else -> LatestWrite.Renamed
}
}
}
@@ -330,34 +357,24 @@ class BackupWorker(
for (plan in plans) {
val target = plan.target
if (latestOnly && plan.latestName == null) continue
val text = try {
val events = repository.exportEvents(target.calendarIds).inBackupOrder()
IcsWriter().writeCalendar(events, stamp, target.calendarName)
} catch (e: CancellationException) {
throw e
} catch (e: Exception) {
Log.w(TAG, "Reading one series failed", e)
val text = (if (target.key in texts) texts.remove(target.key) else export(target)) ?: run {
failed++
continue
}
val fingerprint = backupFingerprint(text)
val fingerprint = fingerprintOf(target, text)
if (latestOnly && !plan.needsRefresh(fingerprint, fingerprints, listing.files.keys, listing.complete)) {
if (plan.latestName in listing.files) landedLatest += target.key
continue
}
val bytes = text.toByteArray(Charsets.UTF_8)
// Not cancellable once a file exists: it must reach the ledger, or
// nothing would ever prune it.
// Not cancellable once a file exists: it must reach the ledger.
withContext(NonCancellable) {
if (!latestOnly) {
if (writeDated(plan, bytes)) written++ else failed++
}
// Best-effort in a full run: it never holds up the run's status.
val dated = if (latestOnly) null else writeDated(plan, bytes)
val latest = plan.latestName?.let { writeLatest(plan, bytes, fingerprint) }
if (latest?.landed == true) landedLatest += target.key
if (latestOnly && latest != null) {
if (latest.failed) failed++ else written++
}
if (latest == LatestWrite.Landed) landedLatest += target.key
// A full run's status follows its dated file; the stable copy is best-effort there.
val ok = dated ?: (latest != LatestWrite.Failed)
if (ok) written++ else failed++
}
}
// A layout switch retires the other layout's copies once every new one is there.
@@ -287,9 +287,15 @@ fun normalizeBackupKeep(stored: Int): Int =
*/
typealias BackupFingerprints = Map<String, String>
/** Hash of a series' file, leaving out the run's `DTSTAMP`s so equal events give an equal hash. */
fun backupFingerprint(ics: String): String {
/**
* Hash of a series' file, leaving out the run's `DTSTAMP`s so equal events give
* an equal hash, and bound to the stable copy's [fileName], so a copy under
* another name never passes as current.
*/
fun backupFingerprint(ics: String, fileName: String): String {
val digest = MessageDigest.getInstance("SHA-256")
digest.update(fileName.toByteArray(Charsets.UTF_8))
digest.update(LINE_BREAK)
ics.lineSequence().filterNot { it.startsWith(DTSTAMP_PREFIX) }
.forEach {
digest.update(it.toByteArray(Charsets.UTF_8))
@@ -343,7 +349,7 @@ fun BackupFilePlan.needsRefresh(
}
/**
* The events in a fixed order, reminders sorted, so the same content always
* The events in a fixed order, their lists sorted, so the same content always
* writes the same file and hashes the same, however the provider returned it.
* Standalone occurrences stay first, as [flattenOverrides] puts them.
*/
@@ -353,4 +359,10 @@ fun List<IcsEvent>.inBackupOrder(): List<IcsEvent> =
{ it.overrideOf == null }, { it.start }, { it.uid }, { it.overrideAt }, { it.calendarName },
),
)
.map { it.copy(reminderMinutes = it.reminderMinutes.sorted()) }
.map {
it.copy(
reminderMinutes = it.reminderMinutes.sorted(),
exDates = it.exDates.sorted(),
recurrenceDates = it.recurrenceDates.sorted(),
)
}
@@ -302,9 +302,10 @@ class BackupPlanTest {
fun `a fingerprint follows the content`() {
val first = "BEGIN:VEVENT\r\nDTSTAMP:20261113T143005Z\r\nSUMMARY:A\r\nEND:VEVENT\r\n"
val later = first.replace("20261113T143005Z", "20261114T090000Z")
assertThat(backupFingerprint(later)).isEqualTo(backupFingerprint(first))
assertThat(backupFingerprint(first.replace("SUMMARY:A", "SUMMARY:B"))).isNotEqualTo(backupFingerprint(first))
assertThat(backupFingerprint(first)).hasLength(32)
assertThat(backupFingerprint(later, "Work.ics")).isEqualTo(backupFingerprint(first, "Work.ics"))
assertThat(backupFingerprint(first.replace("SUMMARY:A", "SUMMARY:B"), "Work.ics")).isNotEqualTo(backupFingerprint(first, "Work.ics"))
assertThat(backupFingerprint(first, "Work.ics")).hasLength(32)
assertThat(backupFingerprint(first, "Job.ics")).isNotEqualTo(backupFingerprint(first, "Work.ics"))
}
@Test
@@ -316,7 +317,7 @@ class BackupPlanTest {
val early = IcsWriter().writeCalendar(listOf(event), Instant.fromEpochSeconds(0), "Work")
val late = IcsWriter().writeCalendar(listOf(event), Instant.fromEpochSeconds(1_800_000_000), "Work")
assertThat(early).isNotEqualTo(late)
assertThat(backupFingerprint(late)).isEqualTo(backupFingerprint(early))
assertThat(backupFingerprint(late, "Work.ics")).isEqualTo(backupFingerprint(early, "Work.ics"))
}
@Test
+5 -3
View File
@@ -500,9 +500,11 @@ it reaches the threshold, and the next success of any run clears it. Since the
trigger fires for any provider change (reminders, other calendars, sync
bookkeeping), each series' file (events in a fixed order) is hashed without its
`DTSTAMP`s (`auto_backup_fingerprints`, reset with the folder) and a change run
skips the series whose hash and stable copy are unchanged; the hash is dropped
before a copy is rewritten. A copy a still-loading folder listing doesn't show,
or one edited in place outside the app, is left to the next scheduled run.
skips the series whose hash (bound to the copy's name) and stable copy are
unchanged, without even listing the folder when no hash moved; the hash is
dropped before a copy is rewritten. A copy that went missing meanwhile, one a
still-loading folder listing doesn't show, or one edited in place outside the
app, is left to the next scheduled run.
**A backup carries the series' deleted and moved occurrences.** `EXDATE` lives on
the master row and is part of `EventExportProjection`; `IcsWriter` marks an