fix(#147, #411): review round 5 - stable copy ownership per series, best-effort writes, layout-switch cleanup
This commit is contained in:
1 parent
88c64d5786
commit
5c05563785
7 files changed
+204
-127
No files matched your search
@@ -28,8 +28,9 @@ import de.jeanlucmakiola.calendula.data.ics.IcsExporter
|
||||
import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.calendula.domain.backup.backupTargets
|
||||
import de.jeanlucmakiola.calendula.domain.backup.planBackupFiles
|
||||
import de.jeanlucmakiola.calendula.domain.backup.updatedBackupLedger
|
||||
import de.jeanlucmakiola.calendula.domain.backup.updatedLatestLedger
|
||||
import de.jeanlucmakiola.calendula.domain.backup.latestLedgerKey
|
||||
import de.jeanlucmakiola.calendula.domain.backup.replacedLatestCopies
|
||||
import de.jeanlucmakiola.calendula.domain.backup.withLedgerEntry
|
||||
import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
|
||||
import de.jeanlucmakiola.floret.android.hasPermission
|
||||
import kotlinx.coroutines.NonCancellable
|
||||
@@ -160,44 +161,69 @@ class BackupWorker(
|
||||
if (targets.isEmpty()) return RunOutcome.NothingSelected
|
||||
val listing = exporter.listFolder(folder)
|
||||
var ledger = prefs.autoBackupLedger.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(
|
||||
targets = targets,
|
||||
ledger = ledger,
|
||||
// A listing still loading can't tell a gone file from a late one.
|
||||
existing = if (listing.complete) listing.files.keys else listing.files.keys + ledger.values.flatten(),
|
||||
existing = existing,
|
||||
at = LocalDateTime.now(),
|
||||
keep = prefs.autoBackupKeep.first(),
|
||||
legacyOwned = prefs.autoBackupLegacyInstall.first(),
|
||||
)
|
||||
val stamp = Clock.System.now()
|
||||
val liveKeys = all.map { it.id.toString() }.toSet()
|
||||
suspend fun record(key: String, files: List<String>) {
|
||||
ledger = withLedgerEntry(ledger, key, files, liveKeys)
|
||||
prefs.setAutoBackupLedger(ledger)
|
||||
}
|
||||
var written = 0
|
||||
for (plan in plans) {
|
||||
try {
|
||||
val target = plan.target
|
||||
val events = repository.exportEvents(target.calendarIds)
|
||||
val content = IcsWriter().writeCalendar(events, stamp, target.calendarName)
|
||||
// Not cancellable once the file exists: it must reach the
|
||||
// ledger, or nothing would ever prune it.
|
||||
withContext(NonCancellable) {
|
||||
val name = exporter.writeToFolder(folder, listing, plan.fileName, content)
|
||||
ledger = updatedBackupLedger(ledger, plan, name, undeleted = plan.prune, liveKeys)
|
||||
prefs.setAutoBackupLedger(ledger)
|
||||
plan.latestName?.let { latest ->
|
||||
val latestName = exporter.writeToFolder(folder, listing, latest, content)
|
||||
ledger = updatedLatestLedger(ledger, plan, latestName, plan.staleLatest, liveKeys)
|
||||
prefs.setAutoBackupLedger(ledger)
|
||||
val staleLeft = exporter.deleteFromFolder(listing, plan.staleLatest)
|
||||
ledger = updatedLatestLedger(ledger, plan, latestName, staleLeft, liveKeys)
|
||||
}
|
||||
val undeleted = exporter.deleteFromFolder(listing, plan.prune)
|
||||
ledger = updatedBackupLedger(ledger, plan, name, undeleted, liveKeys)
|
||||
prefs.setAutoBackupLedger(ledger)
|
||||
}
|
||||
written++
|
||||
val target = plan.target
|
||||
val bytes = try {
|
||||
IcsWriter()
|
||||
.writeCalendar(repository.exportEvents(target.calendarIds), stamp, target.calendarName)
|
||||
.toByteArray(Charsets.UTF_8)
|
||||
} catch (e: CancellationException) {
|
||||
throw e
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Backup of one series failed", e)
|
||||
Log.w(TAG, "Reading one series failed", e)
|
||||
continue
|
||||
}
|
||||
// Not cancellable once a file exists: it must reach the ledger, or
|
||||
// nothing would ever prune it.
|
||||
withContext(NonCancellable) {
|
||||
try {
|
||||
val name = exporter.writeToFolder(folder, listing, plan.fileName, bytes)
|
||||
record(target.key, plan.prune + plan.keep + name)
|
||||
val undeleted = exporter.deleteFromFolder(listing, plan.prune)
|
||||
record(target.key, plan.prune.filter { it in undeleted } + plan.keep + name)
|
||||
written++
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Backup of one series failed", e)
|
||||
}
|
||||
// The stable copy is best-effort: it never holds up the dated
|
||||
// backup, its pruning or the run's status.
|
||||
try {
|
||||
val latestKey = latestLedgerKey(target.key)
|
||||
val latest = plan.latestName?.let { intended ->
|
||||
val landed = exporter.writeToFolder(folder, listing, intended, bytes)
|
||||
// A provider that renamed it leaves a copy to clean up next run.
|
||||
listOf(landed, intended).distinct()
|
||||
}.orEmpty()
|
||||
val owned = ledger[latestKey].orEmpty().filter { it !in plan.staleLatest }
|
||||
record(latestKey, plan.staleLatest + (latest.ifEmpty { owned }))
|
||||
val staleLeft = exporter.deleteFromFolder(listing, plan.staleLatest)
|
||||
record(latestKey, plan.staleLatest.filter { it in staleLeft } + latest.ifEmpty { owned })
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Stable copy of one series failed", e)
|
||||
}
|
||||
}
|
||||
}
|
||||
replacedLatestCopies(targets, ledger, existing).forEach { (key, names) ->
|
||||
withContext(NonCancellable) {
|
||||
val left = exporter.deleteFromFolder(listing, names)
|
||||
record(latestLedgerKey(key), names.filter { it in left })
|
||||
}
|
||||
}
|
||||
return when (written) {
|
||||
|
||||
@@ -39,15 +39,9 @@ class IcsExporter @Inject constructor(
|
||||
return context.contentResolver.listTreeFiles(folder)
|
||||
}
|
||||
|
||||
/** Write [content] as [fileName] into [folder]; returns the name the file ended up with. */
|
||||
fun writeToFolder(folder: Uri, listing: TreeListing, fileName: String, content: String): String =
|
||||
context.contentResolver.writeTreeFile(
|
||||
tree = folder,
|
||||
listing = listing,
|
||||
name = fileName,
|
||||
mimeType = MIME_CALENDAR,
|
||||
bytes = content.toByteArray(Charsets.UTF_8),
|
||||
)
|
||||
/** Write the `.ics` [bytes] as [fileName] into [folder]; returns the name the file ended up with. */
|
||||
fun writeToFolder(folder: Uri, listing: TreeListing, fileName: String, bytes: ByteArray): String =
|
||||
context.contentResolver.writeTreeFile(folder, listing, fileName, MIME_CALENDAR, bytes)
|
||||
|
||||
/** Delete [names] from the listed folder; returns the ones that didn't go. */
|
||||
fun deleteFromFolder(listing: TreeListing, names: Collection<String>): Set<String> =
|
||||
|
||||
@@ -1,12 +1,16 @@
|
||||
package de.jeanlucmakiola.calendula.data.prefs
|
||||
|
||||
import androidx.datastore.core.DataStore
|
||||
import androidx.datastore.preferences.core.MutablePreferences
|
||||
import androidx.datastore.preferences.core.Preferences
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import de.jeanlucmakiola.calendula.domain.EventFormField
|
||||
import de.jeanlucmakiola.calendula.domain.FontRole
|
||||
import de.jeanlucmakiola.calendula.domain.backup.BackupSelection
|
||||
import de.jeanlucmakiola.calendula.domain.backup.COMBINED_SERIES
|
||||
import de.jeanlucmakiola.calendula.domain.backup.DEFAULT_BACKUP_KEEP
|
||||
import de.jeanlucmakiola.calendula.domain.backup.LEGACY_BACKUP_FILE
|
||||
import de.jeanlucmakiola.calendula.domain.backup.latestLedgerKey
|
||||
import de.jeanlucmakiola.calendula.domain.backup.normalizeBackupKeep
|
||||
import de.jeanlucmakiola.calendula.domain.backup.BackupLedger
|
||||
import de.jeanlucmakiola.calendula.domain.backup.parseBackupLedger
|
||||
@@ -191,6 +195,7 @@ class SettingsPrefs @Inject constructor(
|
||||
val autoBackupSelection: Flow<BackupSelection> = prefs.snapshot { it.autoBackupSelection }
|
||||
val autoBackupCombined: Flow<Boolean> = prefs.snapshot { it.autoBackupCombined }
|
||||
val autoBackupKeep: Flow<Int> = prefs.flow(SettingsKeys.autoBackupKeep)
|
||||
val autoBackupLegacyInstall: Flow<Boolean> = prefs.snapshot { it.autoBackupLegacyInstall }
|
||||
val autoBackupLedger: Flow<BackupLedger> = prefs.flow(SettingsKeys.autoBackupLedger)
|
||||
val specialDatesEnabled: Flow<Boolean> = prefs.flow(SettingsKeys.specialDatesEnabled)
|
||||
val specialDatesTypes: Flow<Set<SpecialDateType>> = prefs.snapshot { it.specialDatesTypes }
|
||||
@@ -348,15 +353,17 @@ class SettingsPrefs @Inject constructor(
|
||||
*/
|
||||
suspend fun setAutoBackupFolderUri(uri: String?) {
|
||||
prefs.edit {
|
||||
if (it[SettingsKeys.autoBackupCombinedStored] == null) {
|
||||
it[SettingsKeys.autoBackupCombinedStored] = it[SettingsKeys.autoBackupFolderUri] != null
|
||||
}
|
||||
it.pinBackupLayout()
|
||||
it[SettingsKeys.autoBackupFolderUri] = uri
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun setAutoBackupCombined(combined: Boolean) =
|
||||
prefs.set(SettingsKeys.autoBackupCombinedStored, combined)
|
||||
suspend fun setAutoBackupCombined(combined: Boolean) {
|
||||
prefs.edit {
|
||||
it.pinBackupLayout()
|
||||
it[SettingsKeys.autoBackupCombinedStored] = combined
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun setAutoBackupKeep(keep: Int) = prefs.set(SettingsKeys.autoBackupKeep, keep)
|
||||
|
||||
@@ -822,7 +829,27 @@ val Preferences.autoBackupSelection: BackupSelection
|
||||
* files. Choosing a folder pins the answer (see [SettingsPrefs.setAutoBackupFolderUri]).
|
||||
*/
|
||||
val Preferences.autoBackupCombined: Boolean
|
||||
get() = this[SettingsKeys.autoBackupCombinedStored] ?: (this[SettingsKeys.autoBackupFolderUri] != null)
|
||||
get() = this[SettingsKeys.autoBackupCombinedStored] ?: autoBackupLegacyInstall
|
||||
|
||||
/**
|
||||
* Store the layout the install is on, if it's still derived. Pinning forgets
|
||||
* it was a pre-#411 install, so its old file is recorded as the combined
|
||||
* series' own stable copy at the same time.
|
||||
*/
|
||||
private fun MutablePreferences.pinBackupLayout() {
|
||||
if (this[SettingsKeys.autoBackupCombinedStored] != null) return
|
||||
val legacy = autoBackupLegacyInstall
|
||||
this[SettingsKeys.autoBackupCombinedStored] = legacy
|
||||
if (legacy) {
|
||||
val key = latestLedgerKey(COMBINED_SERIES)
|
||||
val ledger = this[SettingsKeys.autoBackupLedger]
|
||||
this[SettingsKeys.autoBackupLedger] = ledger + (key to (ledger[key].orEmpty() + LEGACY_BACKUP_FILE).distinct())
|
||||
}
|
||||
}
|
||||
|
||||
/** An install that set up automatic backup before #411 and hasn't been pinned since. */
|
||||
val Preferences.autoBackupLegacyInstall: Boolean
|
||||
get() = this[SettingsKeys.autoBackupCombinedStored] == null && this[SettingsKeys.autoBackupFolderUri] != null
|
||||
|
||||
val Preferences.specialDatesTypes: Set<SpecialDateType>
|
||||
get() = SettingsKeys.specialDateTypeEnabled.filterValues { this[it] }.keys
|
||||
|
||||
@@ -96,7 +96,7 @@ const val COMBINED_BACKUP_BASE = "calendula-backup"
|
||||
* The single file every automatic backup overwrote before #411: the combined
|
||||
* series' stable copy now, so an old setup keeps its path.
|
||||
*/
|
||||
const val LEGACY_BACKUP_FILE = "$COMBINED_BACKUP_BASE.ics"
|
||||
val LEGACY_BACKUP_FILE: String = latestFileName(COMBINED_BACKUP_BASE)
|
||||
|
||||
private const val LATEST_PREFIX = "latest-"
|
||||
|
||||
@@ -156,9 +156,11 @@ fun backupFileName(baseName: String, at: LocalDateTime): String =
|
||||
* Plan one run: a new dated file per target, and which of the series' recorded
|
||||
* files ([ledger]) fall out of the newest [keep], the new one included. Recorded
|
||||
* files no longer in the folder ([existing]) are forgotten. Each target also
|
||||
* gets its stable copy, which retention never touches; a renamed series drops
|
||||
* its old one. The pre-#411 [LEGACY_BACKUP_FILE] is the combined series'
|
||||
* stable copy, so it is overwritten rather than left to go stale.
|
||||
* gets its stable copy, which retention never touches. A stable name is only
|
||||
* written when the file is absent or this series owns it — or a series of this
|
||||
* run that is moving off it (a rename hand-off). [legacyOwned]: this install
|
||||
* wrote the pre-#411 [LEGACY_BACKUP_FILE], which is the combined series' stable
|
||||
* copy now.
|
||||
*/
|
||||
fun planBackupFiles(
|
||||
targets: List<BackupTarget>,
|
||||
@@ -166,21 +168,31 @@ fun planBackupFiles(
|
||||
existing: Set<String>,
|
||||
at: LocalDateTime,
|
||||
keep: Int,
|
||||
legacyOwned: Boolean = false,
|
||||
): List<BackupFilePlan> {
|
||||
val retain = keep.coerceAtLeast(1)
|
||||
val ownLatest = ledger.filterKeys { it.startsWith(LATEST_PREFIX) }.values.flatten().toSet() + LEGACY_BACKUP_FILE
|
||||
val runKeys = targets.map { it.key }.toSet()
|
||||
val owners = ledger.filterKeys { it.startsWith(LATEST_PREFIX) }
|
||||
.flatMap { (key, names) -> names.map { it to key.removePrefix(LATEST_PREFIX) } }
|
||||
.toMap()
|
||||
val currentLatest = targets.map { latestFileName(it.baseName) }.toSet()
|
||||
return targets.map { target ->
|
||||
val fileName = backupFileName(target.baseName, at)
|
||||
val earlier = ledger[target.key].orEmpty().filter { it in existing && it != fileName }.distinct()
|
||||
val kept = earlier.takeLast(retain - 1)
|
||||
val latest = latestFileName(target.baseName)
|
||||
val earlier = ledger[target.key].orEmpty()
|
||||
.filter { it in existing && it != fileName && it != latest && it != LEGACY_BACKUP_FILE }
|
||||
.distinct()
|
||||
val kept = earlier.takeLast(retain - 1)
|
||||
val owner = owners[latest]
|
||||
val writable = latest !in existing ||
|
||||
(owner != null && owner in runKeys) ||
|
||||
(latest == LEGACY_BACKUP_FILE && target.key == COMBINED_SERIES && legacyOwned)
|
||||
BackupFilePlan(
|
||||
target = target,
|
||||
fileName = fileName,
|
||||
keep = kept,
|
||||
prune = earlier.dropLast(kept.size),
|
||||
latestName = latest.takeIf { it !in existing || it in ownLatest },
|
||||
latestName = latest.takeIf { writable },
|
||||
staleLatest = ledger[latestLedgerKey(target.key)].orEmpty()
|
||||
.filter { it in existing && it != latest && it !in currentLatest },
|
||||
)
|
||||
@@ -188,45 +200,48 @@ fun planBackupFiles(
|
||||
}
|
||||
|
||||
/**
|
||||
* The ledger once [plan]'s new file landed as [writtenName]: the series records
|
||||
* what it kept, what it failed to delete ([undeleted]) and the new file. Other
|
||||
* series keep their entry while their calendar still exists ([liveKeys]), so a
|
||||
* calendar taken out of the backup still has its files pruned if it's put back.
|
||||
* Stable copies the current layout replaced, per ledger key: a calendar's own
|
||||
* copy once the combined file holds it, or the combined copy once each calendar
|
||||
* has its own. Left in place they would keep serving old data under a path
|
||||
* something may follow. A calendar taken out of the backup keeps its copy.
|
||||
*/
|
||||
fun updatedBackupLedger(
|
||||
previous: BackupLedger,
|
||||
plan: BackupFilePlan,
|
||||
writtenName: String,
|
||||
undeleted: Collection<String>,
|
||||
liveKeys: Set<String>,
|
||||
): BackupLedger {
|
||||
val next = previous.livePart(liveKeys)
|
||||
next[plan.target.key] = (plan.prune.filter { it in undeleted } + plan.keep + writtenName).distinct()
|
||||
return next.filterValues { it.isNotEmpty() }
|
||||
fun replacedLatestCopies(
|
||||
targets: List<BackupTarget>,
|
||||
ledger: BackupLedger,
|
||||
existing: Set<String>,
|
||||
): Map<String, List<String>> {
|
||||
val runKeys = targets.map { it.key }.toSet()
|
||||
val covered = targets.flatMap { it.calendarIds }.map { it.toString() }.toSet()
|
||||
val currentLatest = targets.map { latestFileName(it.baseName) }.toSet()
|
||||
val combinedRun = COMBINED_SERIES in runKeys
|
||||
return ledger.filterKeys { it.startsWith(LATEST_PREFIX) }
|
||||
.mapKeys { it.key.removePrefix(LATEST_PREFIX) }
|
||||
.filterKeys { key ->
|
||||
key !in runKeys && (if (key == COMBINED_SERIES) !combinedRun else combinedRun && key in covered)
|
||||
}
|
||||
.mapValues { (_, names) -> names.filter { it in existing && it !in currentLatest } }
|
||||
.filterValues { it.isNotEmpty() }
|
||||
}
|
||||
|
||||
/**
|
||||
* The ledger once [plan]'s stable copy landed as [writtenName]: recorded with
|
||||
* any stale copy that wouldn't delete ([undeleted]), so a later run retries it.
|
||||
* The ledger with [key]'s files set to [files] (empty drops the entry). Entries
|
||||
* of deleted calendars go ([liveKeys]); their files stay, unrecorded. Others
|
||||
* stay, so a calendar taken out of the backup still has its files pruned if it
|
||||
* is put back.
|
||||
*/
|
||||
fun updatedLatestLedger(
|
||||
fun withLedgerEntry(
|
||||
previous: BackupLedger,
|
||||
plan: BackupFilePlan,
|
||||
writtenName: String,
|
||||
undeleted: Collection<String>,
|
||||
key: String,
|
||||
files: List<String>,
|
||||
liveKeys: Set<String>,
|
||||
): BackupLedger {
|
||||
val next = previous.livePart(liveKeys)
|
||||
next[latestLedgerKey(plan.target.key)] = (plan.staleLatest.filter { it in undeleted } + writtenName).distinct()
|
||||
return next.filterValues { it.isNotEmpty() }
|
||||
}
|
||||
|
||||
/** Entries of calendars that still exist; a deleted calendar's files stay, unrecorded. */
|
||||
private fun BackupLedger.livePart(liveKeys: Set<String>): MutableMap<String, List<String>> =
|
||||
filterKeys { key ->
|
||||
val series = key.removePrefix(LATEST_PREFIX)
|
||||
val next = previous.filterKeys { entry ->
|
||||
val series = entry.removePrefix(LATEST_PREFIX)
|
||||
series in liveKeys || series == COMBINED_SERIES
|
||||
}.toMutableMap()
|
||||
next[key] = files.distinct()
|
||||
return next.filterValues { it.isNotEmpty() }
|
||||
}
|
||||
|
||||
/** `Work.ics`: the series' stable copy. */
|
||||
fun latestFileName(baseName: String): String = "$baseName$ICS_EXTENSION"
|
||||
|
||||
@@ -726,9 +726,15 @@ class SettingsPrefsTest {
|
||||
}
|
||||
assertThat(prefs.autoBackupCombined.first()).isTrue()
|
||||
|
||||
// Picking another folder pins the layout instead of flipping it.
|
||||
assertThat(prefs.autoBackupLegacyInstall.first()).isTrue()
|
||||
|
||||
// Picking another folder pins the layout instead of flipping it, and
|
||||
// keeps the old file recognised as this install's own.
|
||||
prefs.setAutoBackupFolderUri("content://tree/new")
|
||||
assertThat(prefs.autoBackupCombined.first()).isTrue()
|
||||
assertThat(prefs.autoBackupLegacyInstall.first()).isFalse()
|
||||
assertThat(prefs.autoBackupLedger.first())
|
||||
.containsExactly("latest-combined", listOf("calendula-backup.ics"))
|
||||
|
||||
prefs.setAutoBackupCombined(false)
|
||||
assertThat(prefs.autoBackupCombined.first()).isFalse()
|
||||
|
||||
@@ -131,10 +131,22 @@ class BackupPlanTest {
|
||||
private val combined = BackupTarget(COMBINED_SERIES, setOf(1L, 2L), COMBINED_BACKUP_BASE, null)
|
||||
|
||||
@Test
|
||||
fun `the pre-411 backup file becomes the combined series' stable copy`() {
|
||||
val plan = planBackupFiles(listOf(combined), emptyMap(), setOf(LEGACY_BACKUP_FILE), at, keep = 1).single()
|
||||
assertThat(plan.latestName).isEqualTo(LEGACY_BACKUP_FILE)
|
||||
assertThat(plan.prune).isEmpty()
|
||||
fun `the pre-411 file is the combined stable copy only for the install that wrote it`() {
|
||||
val owned = planBackupFiles(listOf(combined), emptyMap(), setOf(LEGACY_BACKUP_FILE), at, 1, legacyOwned = true)
|
||||
assertThat(owned.single().latestName).isEqualTo(LEGACY_BACKUP_FILE)
|
||||
assertThat(owned.single().prune).isEmpty()
|
||||
|
||||
val foreign = planBackupFiles(listOf(combined), emptyMap(), setOf(LEGACY_BACKUP_FILE), at, 1)
|
||||
assertThat(foreign.single().latestName).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a stable name recorded as a dated file by an earlier build is never pruned`() {
|
||||
val ledger = mapOf(COMBINED_SERIES to listOf(LEGACY_BACKUP_FILE, "calendula-backup_a.ics"))
|
||||
val plan = planBackupFiles(
|
||||
listOf(combined), ledger, setOf(LEGACY_BACKUP_FILE, "calendula-backup_a.ics"), at, 1, legacyOwned = true,
|
||||
).single()
|
||||
assertThat(plan.prune).containsExactly("calendula-backup_a.ics")
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -173,12 +185,10 @@ class BackupPlanTest {
|
||||
).single()
|
||||
assertThat(plan.latestName).isEqualTo("Job.ics")
|
||||
assertThat(plan.staleLatest).containsExactly("Work.ics")
|
||||
assertThat(updatedLatestLedger(emptyMap(), plan, "Job.ics", emptySet(), setOf("1")))
|
||||
.containsExactly(latestLedgerKey("1"), listOf("Job.ics"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a stable copy another calendar took over is not deleted, but rewritten by it`() {
|
||||
fun `a stable copy is handed over to the calendar that takes its name in the same run`() {
|
||||
// Calendar 1 was "Work", is now "Job"; calendar 2 is now called "Work".
|
||||
val ledger = mapOf(latestLedgerKey("1") to listOf("Work.ics"))
|
||||
val plans = planBackupFiles(
|
||||
@@ -193,46 +203,43 @@ class BackupPlanTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a deleted calendar's ledger entries are dropped, its files left`() {
|
||||
val plan = planBackupFiles(listOf(work), emptyMap(), emptySet(), at, keep = 1).single()
|
||||
val next = updatedLatestLedger(
|
||||
previous = mapOf(latestLedgerKey("7") to listOf("Gone.ics"), latestLedgerKey(COMBINED_SERIES) to listOf(LEGACY_BACKUP_FILE)),
|
||||
plan = plan,
|
||||
writtenName = "Work.ics",
|
||||
undeleted = emptySet(),
|
||||
liveKeys = setOf("1"),
|
||||
)
|
||||
assertThat(next.keys).containsExactly(latestLedgerKey("1"), latestLedgerKey(COMBINED_SERIES))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `the ledger records what the run kept, failed to delete and wrote`() {
|
||||
fun `a deselected calendar's stable copy is not taken over by a same-named one`() {
|
||||
// Calendar 3 "Personal" is out of the backup; calendar 9, also "Personal", is in.
|
||||
val ledger = mapOf(latestLedgerKey("3") to listOf("Personal.ics"))
|
||||
val plan = planBackupFiles(
|
||||
listOf(work),
|
||||
mapOf("1" to listOf("Work_a.ics", "Work_b.ics")),
|
||||
setOf("Work_a.ics", "Work_b.ics"),
|
||||
at,
|
||||
keep = 2,
|
||||
listOf(BackupTarget("9", setOf(9L), "Personal", "Personal")), ledger, setOf("Personal.ics"), at, 1,
|
||||
).single()
|
||||
val next = updatedBackupLedger(
|
||||
previous = mapOf("1" to listOf("Work_a.ics", "Work_b.ics"), "2" to listOf("Home_a.ics"), "7" to listOf("Gone.ics")),
|
||||
plan = plan,
|
||||
writtenName = "Work_new (1).ics",
|
||||
undeleted = setOf("Work_a.ics"),
|
||||
liveKeys = setOf("1", "2"),
|
||||
)
|
||||
assertThat(next).containsExactly(
|
||||
"1", listOf("Work_a.ics", "Work_b.ics", "Work_new (1).ics"),
|
||||
"2", listOf("Home_a.ics"),
|
||||
)
|
||||
assertThat(plan.latestName).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a pruned file leaves the ledger once it is deleted`() {
|
||||
val plan = planBackupFiles(listOf(work), mapOf("1" to listOf("Work_a.ics")), setOf("Work_a.ics"), at, keep = 1)
|
||||
.single()
|
||||
val next = updatedBackupLedger(mapOf("1" to listOf("Work_a.ics")), plan, "Work_new.ics", emptySet(), setOf("1"))
|
||||
assertThat(next).containsExactly("1", listOf("Work_new.ics"))
|
||||
fun `a layout switch replaces the other layout's stable copies, a deselected calendar keeps its own`() {
|
||||
val ledger = mapOf(
|
||||
latestLedgerKey("1") to listOf("Work.ics"),
|
||||
latestLedgerKey("5") to listOf("Old.ics"),
|
||||
latestLedgerKey(COMBINED_SERIES) to listOf(LEGACY_BACKUP_FILE),
|
||||
)
|
||||
val existing = setOf("Work.ics", "Old.ics", LEGACY_BACKUP_FILE)
|
||||
assertThat(replacedLatestCopies(listOf(combined), ledger, existing))
|
||||
.containsExactly("1", listOf("Work.ics"))
|
||||
assertThat(replacedLatestCopies(listOf(work), ledger, existing))
|
||||
.containsExactly(COMBINED_SERIES, listOf(LEGACY_BACKUP_FILE))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a ledger entry is set, emptied away, and dropped with its calendar`() {
|
||||
val previous = mapOf(
|
||||
"1" to listOf("Work_a.ics"),
|
||||
latestLedgerKey("7") to listOf("Gone.ics"),
|
||||
latestLedgerKey(COMBINED_SERIES) to listOf(LEGACY_BACKUP_FILE),
|
||||
)
|
||||
val next = withLedgerEntry(previous, "1", listOf("Work_a.ics", "Work_b.ics", "Work_b.ics"), setOf("1"))
|
||||
assertThat(next).containsExactly(
|
||||
"1", listOf("Work_a.ics", "Work_b.ics"),
|
||||
latestLedgerKey(COMBINED_SERIES), listOf(LEGACY_BACKUP_FILE),
|
||||
)
|
||||
assertThat(withLedgerEntry(next, "1", emptyList(), setOf("1")).keys)
|
||||
.containsExactly(latestLedgerKey(COMBINED_SERIES))
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -473,13 +473,15 @@ calendar, or one `calendula-backup_…` series in combined mode (#411), and prun
|
||||
each series to the retention count after its new file has landed. Pruning only
|
||||
deletes names recorded in a per-series ledger of files the backup wrote
|
||||
(`auto_backup_files`, keyed by calendar id), never whatever happens to match a
|
||||
name, so renames, same-named calendars and the user's own files are safe; the
|
||||
name, so renames, same-named calendars and the user's own files are safe.
|
||||
Each series also keeps a stable undated copy (`<calendar name>.ics`, or
|
||||
`calendula-backup.ics` combined) overwritten every run, so sync tools and
|
||||
subscriptions can follow one path; retention never touches it, it never
|
||||
overwrites a file the backup didn't write, and a renamed calendar's old copy is
|
||||
deleted while a deselected one's is kept. The pre-#411 fixed
|
||||
`calendula-backup.ics` simply is the combined series' stable copy, and an
|
||||
subscriptions can follow one path. Retention never touches it, and it is only
|
||||
written over a file the series itself (or a series renaming away from that name
|
||||
in the same run) recorded. A renamed calendar's old copy is deleted, and so is a
|
||||
copy the layout switch replaced (per-calendar ↔ combined); a calendar taken out
|
||||
of the backup keeps its last one. The pre-#411 fixed `calendula-backup.ics` is
|
||||
the combined series' stable copy for the install that wrote it, and an
|
||||
install that already had a folder stays on the combined layout.
|
||||
|
||||
**A backup carries the series' deleted occurrences.** `EXDATE` lives on the
|
||||
|
||||
Reference in new issue
Block a user