diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index d1cf168a..b6c68bbc 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -131,7 +131,20 @@ Ask to be brought back Approve Take part in rotating the shares - Store your new share + Every member takes part. + Without %1$s. + %1$s until they are brought back + %1$s for good + Your device then sends its part, stores your new share and signs the group\'s new key state without asking again. + Rotating the shares + Members are sending their parts of the new shares. + Members are storing their new shares. + The group is signing its new key state. The old shares are deleted once it has. + If someone has stopped answering, any member taking part can abandon the rotation. Every share stays as it was, and the group can start again. + Abandon rotation + Abandon this rotation? + It ends for every member. Nobody gets a new share, and the group keeps signing with the shares it has. + The last rotation ended: %1$s Help bring a member back Sent to the group Share rotation proposed; every remaining member is asked to take part diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ShareRefreshDao.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ShareRefreshDao.kt index d699c000..bb4d1fee 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ShareRefreshDao.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ShareRefreshDao.kt @@ -44,6 +44,9 @@ abstract class ShareRefreshDao { @Upsert abstract suspend fun upsert(message: ShareRefreshMessage) + @Query("SELECT * FROM ShareRefreshMessage WHERE sessionId = :sessionId") + abstract suspend fun getMessagesForSession(sessionId: String): List + @Query("SELECT * FROM ShareRefreshMessage WHERE sessionId = :sessionId AND kind = :kind") abstract suspend fun getMessagesByKind(sessionId: String, kind: Kind): List diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseChatRepository.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseChatRepository.kt index 0c99990f..cf1e27a4 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseChatRepository.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseChatRepository.kt @@ -1,5 +1,8 @@ package mobi.giza.compose.database.repository +import mobi.giza.compose.database.model.ShareRefreshSession +import mobi.giza.compose.nostr.frost.GroupKeyStateEvent +import com.vitorpamplona.quartz.nip01Core.core.Event import co.touchlab.kermit.Logger import com.vitorpamplona.quartz.marmot.mip02Welcome.WelcomeEvent import com.vitorpamplona.quartz.nip01Core.core.HexKey @@ -667,30 +670,89 @@ class DatabaseChatRepository( val shares = ShareGenerations.active(database, key) if (shares.roster.isEmpty()) return null val names = localChatRoom.localParticipants.associate { it.participant.participantPublicKey to it.profile?.humanReadableNameOrPubkey() } + fun nameOf(member: HexKey) = names[member] ?: member.take(8) val refreshes = database.shareRefreshDao().getSessionsForKey(key.id) val repairs = database.shareRepairDao().getSessionsForKey(key.id) val pending = refreshes.mapNotNull { session -> when (ShareRefreshManager.pendingApproval(database, session)) { - ShareRefreshApprovalStep.DEAL -> SharesSummary.PendingApproval(session.id, SharesSummary.PendingApproval.Kind.REFRESH_DEAL) - ShareRefreshApprovalStep.CONFIRM -> SharesSummary.PendingApproval(session.id, SharesSummary.PendingApproval.Kind.REFRESH_CONFIRM) - null -> null + ShareRefreshApprovalStep.DEAL -> { + val roster = ShareGenerations.at(database, key, session.baseGeneration)?.roster.orEmpty() + .associate { it.participantId to it.memberPublicKey } + SharesSummary.PendingApproval( + sessionId = session.id, + kind = SharesSummary.PendingApproval.Kind.REFRESH_DEAL, + withheld = session.withheldStandings().map { (id, standing) -> + SharesSummary.Withheld(roster[id]?.let(::nameOf) ?: id.toString(), standing) + }, + ) + } + // Never pending since docs/rotate-shares-single-approval.md. + ShareRefreshApprovalStep.CONFIRM, null -> null } } + repairs.filter { ShareRepairManager.isAwaitingApproval(database, it) } .map { SharesSummary.PendingApproval(it.id, SharesSummary.PendingApproval.Kind.REPAIR_HELP) } - val running = refreshes.any { it.stage != ShareRefreshStage.COMPLETE && it.stage != ShareRefreshStage.FAILED } + val runningRefresh = refreshes.firstOrNull { it.stage != ShareRefreshStage.COMPLETE && it.stage != ShareRefreshStage.FAILED } + val running = runningRefresh?.let { session -> + // The approval row covers a member not yet asked; this is everything after it. + if (ShareRefreshManager.pendingApproval(database, session) != null) return@let null + ShareRefreshManager.progress(database, session)?.let { progress -> + SharesSummary.Running( + sessionId = session.id, + step = when (progress.step) { + ShareRefreshManager.Progress.Step.DEALING -> SharesSummary.Running.Step.DEALING + ShareRefreshManager.Progress.Step.STORING -> SharesSummary.Running.Step.STORING + }, + waitingOn = progress.waitingOn.map(::nameOf), + since = progress.since, + canAbandon = progress.canAbandon, + ) + } + } ?: signingNewGeneration(localChatRoom, key, shares.generation, refreshes) val mine = shares.roster.firstOrNull { it.memberPublicKey == me } val repairing = repairs.any { it.targetPublicKey == me && it.stage != ShareRepairStage.FAILED && it.stage != ShareRepairStage.COMPLETE } SharesSummary( generation = shares.generation, members = shares.roster.map { entry -> - SharesSummary.Member(entry.memberPublicKey, names[entry.memberPublicKey] ?: entry.memberPublicKey.take(8), entry.standing, entry.memberPublicKey == me) + SharesSummary.Member(entry.memberPublicKey, nameOf(entry.memberPublicKey), entry.standing, entry.memberPublicKey == me) }, pending = if (ExperimentalFeatures.shareRefresh) pending else emptyList(), - canRotate = ExperimentalFeatures.shareRefresh && shares.secretShare != null && !running, + canRotate = ExperimentalFeatures.shareRefresh && shares.secretShare != null && runningRefresh == null, canAskToBeRepaired = ExperimentalFeatures.shareRefresh && mine?.standing == ShareStanding.STALE && !repairing, + running = running.takeIf { ExperimentalFeatures.shareRefresh }, + lastFailure = refreshes.firstOrNull()?.takeIf { it.stage == ShareRefreshStage.FAILED }?.failureReason + ?.takeIf { ExperimentalFeatures.shareRefresh }, ) }.getOrNull() + /** + * The last step of a rotation: complete, and the group signing the new + * generation's key state, which the old shares wait on before they are + * deleted. Shown only while that signature is actually open, so a key state + * nobody is asking for does not read as one under way. + */ + private suspend fun signingNewGeneration( + localChatRoom: LocalChatRoom, + key: DkgSession, + generation: Int, + refreshes: List, + ): SharesSummary.Running? { + val refresh = refreshes.firstOrNull { it.stage == ShareRefreshStage.COMPLETE && it.baseGeneration + 1 == generation } ?: return null + val signed = GroupKeyStateManager.signedStateFor(database, localChatRoom.chatRoom.id) + if ((signed?.generation ?: 0) >= generation) return null + val signing = database.frostSigningSessionDao() + val open = signing.getOpenSessionsForKey(key.id).firstOrNull { session -> + (session.generation ?: 0) == generation && signing.getItems(session.id).singleOrNull() + ?.let { Event.fromJsonOrNull(it.unsignedEventJson)?.kind } == GroupKeyStateEvent.KIND + } ?: return null + return SharesSummary.Running( + sessionId = refresh.id, + step = SharesSummary.Running.Step.SIGNING, + waitingOn = emptyList(), + since = open.createdAt, + canAbandon = false, + ) + } + private fun failureOf(t: Throwable?): String? = t?.let { it.message ?: it::class.simpleName ?: "Unknown error" } private fun privateKeyOrNull(): Pair? { @@ -723,7 +785,7 @@ class DatabaseChatRepository( val (_, privateKey) = privateKeyOrNull() ?: return "This identity cannot sign" return failureOf(runCatching { when (approval.kind) { - SharesSummary.PendingApproval.Kind.REFRESH_DEAL, SharesSummary.PendingApproval.Kind.REFRESH_CONFIRM -> + SharesSummary.PendingApproval.Kind.REFRESH_DEAL -> ShareRefreshManager.approve(database, localChatRoom, approval.sessionId, privateKey) SharesSummary.PendingApproval.Kind.REPAIR_HELP -> ShareRepairManager.approve(database, localChatRoom, approval.sessionId, privateKey) diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ShareRefreshManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ShareRefreshManager.kt index 61b551e2..84e1370a 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ShareRefreshManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ShareRefreshManager.kt @@ -426,10 +426,14 @@ object ShareRefreshManager { logger.w("Refresh ${session.id}: kind ${innerEvent.kind} from ${innerEvent.pubKey.take(8)}, who is not a recipient; ignoring") return true } + // Stored once, on first arrival: its time is when the rotation last + // moved, and a relay repeating itself is not progress ([progress]). val known = database.shareRefreshDao().getMessage(session.id, innerEvent.kind, innerEvent.pubKey) != null - database.shareRefreshDao().upsert(ShareRefreshMessage(session.id, innerEvent.pubKey, innerEvent.kind, innerEvent.content)) - if (!known && innerEvent.pubKey != session.userPublicKey) { - announce(database, session, stepType(innerEvent.kind), stepLine(innerEvent.kind), innerEvent.pubKey) + if (!known) { + database.shareRefreshDao().upsert(ShareRefreshMessage(session.id, innerEvent.pubKey, innerEvent.kind, innerEvent.content)) + if (innerEvent.pubKey != session.userPublicKey) { + announce(database, session, stepType(innerEvent.kind), stepLine(innerEvent.kind), innerEvent.pubKey) + } } } @@ -686,6 +690,43 @@ object ShareRefreshManager { return if (session.dealApprovedAt == null) ShareRefreshApprovalStep.DEAL else null } + /** + * Where a running refresh stands, as the Shares section shows it once its one + * approval is given: which step, who it waits on, since when, and whether + * this device may abandon it (docs/rotate-shares-single-approval.md, Phase 6). + * Null once it has finished. + * + * With nothing left to approve, this is the only place a member who took part + * can see a rotation stall, and the only way they can end it. + */ + suspend fun progress(database: GizaDatabase, session: ShareRefreshSession): Progress? { + if (session.stage == ShareRefreshStage.COMPLETE || session.stage == ShareRefreshStage.FAILED) return null + val key = database.dkgSessionDao().getSessionById(session.dkgSessionId) ?: return null + val base = ShareGenerations.at(database, key, session.baseGeneration) ?: return null + val memberOf = base.roster.associate { it.participantId to it.memberPublicKey } + val recipients = session.recipientIdList() + val messages = database.shareRefreshDao().getMessagesForSession(session.id) + fun missing(kind: Kind) = recipients + .filter { id -> messages.none { it.kind == kind && it.participantPublicKey == memberOf[id] } } + .mapNotNull { memberOf[it] } + val (step, waitingOn) = when { + session.coordinatorRound1 == null -> Progress.Step.DEALING to missing(ShareRefreshEvents.ROUND_1).ifEmpty { listOf(session.coordinatorPublicKey) } + else -> Progress.Step.STORING to missing(ShareRefreshEvents.ROUND_2).ifEmpty { listOf(session.coordinatorPublicKey) } + } + val myId = memberOf.entries.firstOrNull { it.value == session.userPublicKey }?.key + return Progress( + step = step, + waitingOn = waitingOn, + since = messages.maxOfOrNull { it.createdAt } ?: session.createdAt, + canAbandon = myId != null && myId in recipients, + ) + } + + /** See [progress]. */ + data class Progress(val step: Step, val waitingOn: List, val since: Instant, val canAbandon: Boolean) { + enum class Step { DEALING, STORING } + } + /** Approves the step this device's owner is being asked for, and moves on. */ suspend fun approve(database: GizaDatabase, localChatRoom: LocalChatRoom, sessionId: String, nostrPrivateKey: ByteArray) { val session = database.shareRefreshDao().getSessionById(sessionId) ?: return @@ -736,9 +777,9 @@ object ShareRefreshManager { /** Queues this device's own message and records it, so the coordinator's own is in its sums. */ private suspend fun publishOwn(database: GizaDatabase, localChatRoom: LocalChatRoom, session: ShareRefreshSession, kind: Kind, content: String) { broadcast(database, localChatRoom, session, kind, content, ShareRefreshEvents.assembleTags(session.id)) - val known = ownMessage(database, session, kind) != null + if (ownMessage(database, session, kind) != null) return database.shareRefreshDao().upsert(ShareRefreshMessage(session.id, session.userPublicKey, kind, content)) - if (!known) announce(database, session, stepType(kind), stepLine(kind), session.userPublicKey) + announce(database, session, stepType(kind), stepLine(kind), session.userPublicKey) } /** One of this device's messages, as an inner event of the key's Marmot room. */ diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomDetailScreen.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomDetailScreen.kt index abbc23f5..10b8e07b 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomDetailScreen.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomDetailScreen.kt @@ -104,7 +104,6 @@ import mobi.giza.compose.resources.leave_group import mobi.giza.compose.resources.remove_from_group import mobi.giza.compose.resources.shares_action_sent import mobi.giza.compose.resources.pending_repair_help -import mobi.giza.compose.resources.pending_rotation_confirm import mobi.giza.compose.resources.pending_rotation_deal import mobi.giza.compose.resources.abandon import mobi.giza.compose.resources.approve @@ -132,6 +131,23 @@ import mobi.giza.compose.resources.rotation_proposing_is_taking_part import mobi.giza.compose.resources.rotation_taking_part import mobi.giza.compose.resources.rotation_no_key import mobi.giza.compose.ui.view.state.RotationPreview +import androidx.compose.runtime.remember +import androidx.compose.material3.CardDefaults +import mobi.giza.compose.resources.waiting_on_s_since_s +import mobi.giza.compose.resources.rotation_ended +import mobi.giza.compose.resources.abandon_rotation_body +import mobi.giza.compose.resources.abandon_rotation_question +import mobi.giza.compose.resources.abandon_rotation +import mobi.giza.compose.resources.rotation_abandon_explainer +import mobi.giza.compose.resources.rotation_step_signing +import mobi.giza.compose.resources.rotation_step_storing +import mobi.giza.compose.resources.rotation_step_dealing +import mobi.giza.compose.resources.rotation_running +import mobi.giza.compose.resources.pending_rotation_commits +import mobi.giza.compose.resources.rotation_withheld_for_good +import mobi.giza.compose.resources.rotation_withheld_until_back +import mobi.giza.compose.resources.pending_rotation_without +import mobi.giza.compose.resources.pending_rotation_everyone import androidx.compose.material3.AlertDialog import mobi.giza.compose.resources.disband_group import mobi.giza.compose.resources.disband_group_explainer @@ -226,6 +242,33 @@ fun ChatRoomDetailScreen( ) } + var abandoningRotation by remember { mutableStateOf(null) } + abandoningRotation?.let { sessionId -> + AlertDialog( + onDismissRequest = { abandoningRotation = null }, + title = { Text(stringResource(Res.string.abandon_rotation_question)) }, + text = { Text(stringResource(Res.string.abandon_rotation_body)) }, + confirmButton = { + TextButton( + onClick = { + abandoningRotation = null + (chatRoomDetailViewModel.chatRoomDetailUIState as? ChatRoomDetailUIState.Loaded)?.let { loaded -> + chatRoomDetailViewModel.abandonRotation(loaded.localChatRoom, sessionId) { failure -> notify(failure ?: sharesActionSent) } + } + }, + colors = ButtonDefaults.textButtonColors(contentColor = MaterialTheme.colorScheme.error) + ) { + Text(stringResource(Res.string.abandon_rotation)) + } + }, + dismissButton = { + TextButton(onClick = { abandoningRotation = null }) { + Text(stringResource(Res.string.not_now)) + } + }, + ) + } + // The proposer's one approval: the rotation as it will be proposed, with // everyone it leaves out named (docs/rotate-shares-single-approval.md, Phase 4). chatRoomDetailViewModel.rotationProposal?.let { proposal -> @@ -431,6 +474,28 @@ fun ChatRoomDetailScreen( style = MaterialTheme.typography.bodyMedium ) } + // Above the members: with nothing left to approve, this is + // where a member who took part sees a rotation stall, and the + // only way out of one (docs/rotate-shares-single-approval.md). + shares.running?.let { running -> + item(key = "rotation-running") { + RotationRunningCard( + running = running, + onAbandon = { abandoningRotation = running.sessionId }, + ) + } + } + if (shares.running == null) { + shares.lastFailure?.let { reason -> + item(key = "rotation-ended") { + Text( + text = stringResource(Res.string.rotation_ended, reason), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant + ) + } + } + } items(items = shares.members, key = { member -> "share-${member.publicKey}" }) { member -> ListItem( headlineContent = { @@ -456,12 +521,18 @@ fun ChatRoomDetailScreen( stringResource( when (approval.kind) { SharesSummary.PendingApproval.Kind.REFRESH_DEAL -> Res.string.pending_rotation_deal - SharesSummary.PendingApproval.Kind.REFRESH_CONFIRM -> Res.string.pending_rotation_confirm SharesSummary.PendingApproval.Kind.REPAIR_HELP -> Res.string.pending_repair_help } ) ) }, + // Taking part is agreeing to who is left out, and it is the + // only thing this rotation will ask: so the row says both. + supportingContent = if (approval.kind == SharesSummary.PendingApproval.Kind.REFRESH_DEAL) { + { RotationTakingPart(approval.withheld) } + } else { + null + }, trailingContent = { Row(horizontalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.relatedGap)) { if (approval.kind != SharesSummary.PendingApproval.Kind.REPAIR_HELP) { @@ -1394,3 +1465,70 @@ private fun RotationLeftOut(preview: RotationPreview) { Text(stringResource(Res.string.rotation_left_out_for_good, preview.forGood.joinToString(", "))) } } + +/** What taking part in a rotation agrees to: who it leaves out, and that nothing more will be asked. */ +@Composable +private fun RotationTakingPart(withheld: List) { + val leftOut = withheld.map { entry -> + stringResource( + if (entry.standing == ShareStanding.RETIRED) Res.string.rotation_withheld_for_good else Res.string.rotation_withheld_until_back, + entry.name + ) + } + Column { + Text( + if (leftOut.isEmpty()) stringResource(Res.string.pending_rotation_everyone) + else stringResource(Res.string.pending_rotation_without, leftOut.joinToString(", ")) + ) + Text(stringResource(Res.string.pending_rotation_commits)) + } +} + +/** + * A rotation past its one approval: the step it is on, who it waits on and since + * when, and abandon for a member taking part. Shown whether or not it has + * stalled -- unlike a ceremony, a rotation has no screen of its own to show it. + */ +@Composable +private fun RotationRunningCard(running: SharesSummary.Running, onAbandon: () -> Unit) { + Card( + modifier = Modifier.fillMaxWidth(), + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.secondaryContainer, + contentColor = MaterialTheme.colorScheme.onSecondaryContainer + ) + ) { + Column( + modifier = Modifier.fillMaxWidth().padding(MaterialTheme.spacing.containerPadding), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.relatedGap) + ) { + Text(stringResource(Res.string.rotation_running), style = MaterialTheme.typography.titleSmall) + Text( + stringResource( + when (running.step) { + SharesSummary.Running.Step.DEALING -> Res.string.rotation_step_dealing + SharesSummary.Running.Step.STORING -> Res.string.rotation_step_storing + SharesSummary.Running.Step.SIGNING -> Res.string.rotation_step_signing + } + ), + style = MaterialTheme.typography.bodyMedium + ) + if (running.waitingOn.isNotEmpty()) { + Text( + stringResource(Res.string.waiting_on_s_since_s, running.waitingOn.joinToString(", "), running.since.toFormattedTimeAndDateString()), + style = MaterialTheme.typography.bodyMedium + ) + } + if (running.canAbandon) { + Text(stringResource(Res.string.rotation_abandon_explainer), style = MaterialTheme.typography.bodyMedium) + TextButton( + onClick = onAbandon, + modifier = Modifier.align(Alignment.End), + colors = ButtonDefaults.textButtonColors(contentColor = MaterialTheme.colorScheme.error) + ) { + Text(stringResource(Res.string.abandon_rotation)) + } + } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/SharesSummary.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/SharesSummary.kt index 720377f0..af7dbc63 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/SharesSummary.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/SharesSummary.kt @@ -1,12 +1,13 @@ package mobi.giza.compose.ui.view.state import com.vitorpamplona.quartz.nip01Core.core.HexKey +import kotlin.time.Instant import mobi.giza.compose.database.model.types.ShareStanding /** * A room's key, as the Shares section shows it (docs/frost-share-refresh.md, * Phase 11): the generation the group signs with, who holds what, what this - * device is being asked, and what it may start. + * device is being asked, what is running, and what it may start. */ data class SharesSummary( val generation: Int, @@ -16,11 +17,38 @@ data class SharesSummary( val canRotate: Boolean, /** This device's own id is stale and nothing is bringing it back yet. */ val canAskToBeRepaired: Boolean, + /** A rotation under way, from its one approval until the group signs the new generation. */ + val running: Running? = null, + /** Why the newest rotation ended, when it ended without completing and nothing has run since. */ + val lastFailure: String? = null, ) { data class Member(val publicKey: HexKey, val name: String, val standing: ShareStanding, val isSelf: Boolean) - /** Something this device's owner is being asked, and the session it is for. */ - data class PendingApproval(val sessionId: String, val kind: Kind) { - enum class Kind { REFRESH_DEAL, REFRESH_CONFIRM, REPAIR_HELP } + /** + * Something this device's owner is being asked, and the session it is for. + * A rotation's carries who it leaves out, because agreeing to that is what + * taking part is (docs/rotate-shares-single-approval.md, Phase 6). + */ + data class PendingApproval(val sessionId: String, val kind: Kind, val withheld: List = emptyList()) { + /** A rotation asks one thing, to take part; storing the new share stopped being a question. */ + enum class Kind { REFRESH_DEAL, REPAIR_HELP } + } + + data class Withheld(val name: String, val standing: ShareStanding) + + /** + * A rotation running past its one approval. With nothing left to approve, + * this is the only place a member who took part sees it stall, and the only + * way out of one. + */ + data class Running( + val sessionId: String, + val step: Step, + val waitingOn: List, + val since: Instant, + /** This device is a recipient of a rotation not yet certified, so it may end it for everyone. */ + val canAbandon: Boolean, + ) { + enum class Step { DEALING, STORING, SIGNING } } } diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt index fbe26bbd..9f504526 100644 --- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt @@ -657,6 +657,123 @@ class ShareRefreshRitualJvmTest { assertEquals(0, FrostSigningManager.resumeVouched(member.db, member.publicKey), "once") } + // ---- Phase 6 of rotate-shares-single-approval: the Shares section ------------------------------------------------ + + private suspend fun summaryOn(device: Device): mobi.giza.compose.ui.view.state.SharesSummary { + val scope = kotlinx.coroutines.CoroutineScope(kotlinx.coroutines.Dispatchers.Unconfined + kotlinx.coroutines.Job()) + return try { + assertNotNull(mobi.giza.compose.database.repository.DatabaseChatRepository(device.db, scope).sharesSummary(device.room), "device ${device.index}") + } finally { + scope.coroutineContext[kotlinx.coroutines.Job]?.cancel() + } + } + + private fun nameOf(device: Device) = device.publicKey.take(8) + + @Test + fun `a rotation asks one thing, to take part`() { + assertEquals( + listOf(mobi.giza.compose.ui.view.state.SharesSummary.PendingApproval.Kind.REFRESH_DEAL, mobi.giza.compose.ui.view.state.SharesSummary.PendingApproval.Kind.REPAIR_HELP), + mobi.giza.compose.ui.view.state.SharesSummary.PendingApproval.Kind.entries.toList(), + ) + } + + /** Taking part is agreeing to who is left out, so the row that asks it names them. */ + @Test + fun `the taking-part row names who is left out, and the withheld member sees the rotation run`() = runBlocking { + val group = Group(3, 2) + val all = devicesFor(group) + propose(all[0], mapOf(group.idOf[2] to ShareStanding.STALE)) + pump(all) + + val asked = summaryOn(all[1]) + val row = asked.pending.single() + assertEquals(mobi.giza.compose.ui.view.state.SharesSummary.PendingApproval.Kind.REFRESH_DEAL, row.kind) + assertEquals(listOf(mobi.giza.compose.ui.view.state.SharesSummary.Withheld(nameOf(all[2]), ShareStanding.STALE)), row.withheld) + assertNull(asked.running, "the row covers a member not yet asked") + + val withheld = summaryOn(all[2]) + assertTrue(withheld.pending.isEmpty()) + val running = assertNotNull(withheld.running) + assertEquals(listOf(nameOf(all[1])), running.waitingOn) + assertTrue(!running.canAbandon, "only a member taking part may end it") + } + + /** + * Once a member has taken part there is nothing left to approve, so the + * running rotation is what they see: the step, who it waits on, and abandon. + */ + @Test + fun `a running rotation names who it waits on at each step`() = runBlocking { + val group = Group(3, 2) + val all = devicesFor(group) + val (alice, bob, carol) = all + val refresh = propose(alice) + pump(all) + ShareRefreshManager.approve(bob.db, bob.room, refresh.id, bob.privateKey) + pump(all) + + val dealing = assertNotNull(summaryOn(bob).running) + assertEquals(mobi.giza.compose.ui.view.state.SharesSummary.Running.Step.DEALING, dealing.step) + assertEquals(listOf(nameOf(carol)), dealing.waitingOn) + assertTrue(dealing.canAbandon, "a member who took part can still end it") + assertTrue(summaryOn(bob).pending.isEmpty()) + assertTrue(!summaryOn(bob).canRotate) + + // Carol takes part; her confirmation is slow to arrive. + ShareRefreshManager.approve(carol.db, carol.room, refresh.id, carol.privateKey) + pump(all, hold = { it.kind == ShareRefreshEvents.ROUND_2 && it.publicKey == carol.publicKey }) + val storing = assertNotNull(summaryOn(bob).running) + assertEquals(mobi.giza.compose.ui.view.state.SharesSummary.Running.Step.STORING, storing.step) + assertEquals(listOf(nameOf(carol)), storing.waitingOn) + + // A relay repeating itself is not progress. Dated a day back first, so a + // redelivery that rewrote a row would show, whatever the clock's precision. + val dao = bob.db.shareRefreshDao() + val dayAgo = kotlin.time.Clock.System.now() - kotlin.time.Duration.parse("1d") + dao.getMessagesForSession(refresh.id).forEach { dao.upsert(it.copy(createdAt = dayAgo, updatedAt = dayAgo, savedAt = dayAgo)) } + val since = assertNotNull(summaryOn(bob).running).since + assertTrue(kotlin.time.Clock.System.now() - since > kotlin.time.Duration.parse("23h")) + bob.received.clear() + pump(all, hold = { it.kind == ShareRefreshEvents.ROUND_2 && it.publicKey == carol.publicKey }) + assertEquals(since, summaryOn(bob).running?.since, "a redelivered message moved the stall clock") + } + + @Test + fun `the last step is the group signing the new key state, which nobody abandons`() = runBlocking { + val group = Group(3, 2) + val all = devicesFor(group) + val refresh = propose(all[0]) + pump(all) + all.forEach { ShareRefreshManager.approve(it.db, it.room, refresh.id, it.privateKey) } + pump(all, hold = { FrostSigningEvents.isProposal(it.kind) }) + + val signing = assertNotNull(summaryOn(all[0]).running, "the coordinator's own key state is open") + assertEquals(mobi.giza.compose.ui.view.state.SharesSummary.Running.Step.SIGNING, signing.step) + assertTrue(!signing.canAbandon) + + pump(all) + all.forEach { assertNull(summaryOn(it).running, "device ${it.index}: nothing is running once it is signed") } + } + + @Test + fun `an abandoned rotation says why until the next one`() = runBlocking { + val group = Group(3, 2) + val all = devicesFor(group) + val refresh = propose(all[0]) + pump(all) + ShareRefreshManager.approve(all[1].db, all[1].room, refresh.id, all[1].privateKey) + ShareRefreshManager.abandon(all[1].db, all[1].room, refresh.id) + pump(all) + + all.forEach { device -> + val summary = summaryOn(device) + assertNull(summary.running) + assertTrue(summary.lastFailure!!.contains("Abandoned"), summary.lastFailure) + assertTrue(summary.canRotate) + } + } + @Test fun `a withheld member ends with the new table and no share, and declines to sign`() = runBlocking { val group = Group(3, 2)