From 986876c812469d64cfece807a2571536669d5aaf Mon Sep 17 00:00:00 2001 From: Jade Ellis Date: Thu, 22 May 2025 15:28:46 +0100 Subject: [PATCH] chore: cleanup --- src/admin/room/commands.rs | 155 ++++++++++++++++--------------------- src/admin/room/mod.rs | 11 +-- 2 files changed, 69 insertions(+), 97 deletions(-) diff --git a/src/admin/room/commands.rs b/src/admin/room/commands.rs index 5e25ec7a..2a4e60ac 100644 --- a/src/admin/room/commands.rs +++ b/src/admin/room/commands.rs @@ -96,32 +96,23 @@ pub(crate) enum RoomTargetOption { } #[admin_command] -pub(super) async fn purge_empty_room_tokens( +pub(super) async fn purge_all_sync_tokens( &self, - yes: bool, target_option: Option, - dry_run: bool, + execute: bool, ) -> Result { use conduwuit::{debug, info}; - if !yes && !dry_run { - return Err!( - "Please confirm this operation with --yes as it may delete tokens from many rooms, \ - or use --dry-run to simulate" - ); - } - - let mode = if dry_run { "Simulating" } else { "Starting" }; + let mode = if !execute { "Simulating" } else { "Starting" }; // strictly, we should check if these reach the max value after the loop and // warn the user that the count is too large - let mut total_rooms_processed: usize = 0; - let mut empty_rooms_processed: u32 = 0; + let mut total_rooms_checked: usize = 0; let mut total_tokens_deleted: usize = 0; let mut error_count: u32 = 0; - let mut skipped_rooms: u32 = 0; + let mut skipped_rooms: usize = 0; - info!("{} purge of sync tokens for rooms with no local users", mode); + info!("{} purge of sync tokens", mode); // Get all rooms in the server let all_rooms = self @@ -169,102 +160,86 @@ pub(super) async fn purge_empty_room_tokens( // Process each room for room_id in rooms { - total_rooms_processed = total_rooms_processed.saturating_add(1); - - // Count local users in this room - let local_users_count = self - .services - .rooms - .state_cache - .local_users_in_room(room_id) - .count() - .await; - - // Only process rooms with no local users - if local_users_count == 0 { - empty_rooms_processed = empty_rooms_processed.saturating_add(1); - - // In dry run mode, just count what would be deleted, don't actually delete - debug!( - "Room {} has no local users, {}", - room_id, - if dry_run { - "would purge sync tokens" - } else { - "purging sync tokens" - } - ); - - if dry_run { - // For dry run mode, count tokens without deleting - match self.services.rooms.user.count_room_tokens(room_id).await { - | Ok(count) => - if count > 0 { - debug!("Would delete {} sync tokens for room {}", count, room_id); - total_tokens_deleted = total_tokens_deleted.saturating_add(count); - } else { - debug!("No sync tokens found for room {}", room_id); - }, - | Err(e) => { - debug!("Error counting sync tokens for room {}: {:?}", room_id, e); - error_count = error_count.saturating_add(1); - }, - } - } else { - // Real deletion mode - match self.services.rooms.user.delete_room_tokens(room_id).await { - | Ok(count) => - if count > 0 { - debug!("Deleted {} sync tokens for room {}", count, room_id); - total_tokens_deleted = total_tokens_deleted.saturating_add(count); - } else { - debug!("No sync tokens found for room {}", room_id); - }, - | Err(e) => { - debug!("Error purging sync tokens for room {}: {:?}", room_id, e); - error_count = error_count.saturating_add(1); - }, - } - } - } else { - debug!("Room {} has {} local users, skipping", room_id, local_users_count); - } + total_rooms_checked = total_rooms_checked.saturating_add(1); // Log progress periodically - if total_rooms_processed % 100 == 0 || total_rooms_processed == total_rooms { + if total_rooms_checked % 100 == 0 || total_rooms_checked == total_rooms { info!( - "Progress: {}/{} rooms processed, {} empty rooms found, {} tokens {}", - total_rooms_processed, + "Progress: {}/{} rooms checked, {} tokens {}", + total_rooms_checked, total_rooms, - empty_rooms_processed, total_tokens_deleted, - if dry_run { "would be deleted" } else { "deleted" } + if !execute { "would be deleted" } else { "deleted" } ); } + + // In dry run mode, just count what would be deleted, don't actually delete + debug!( + "Room {} has no local users, {}", + room_id, + if !execute { + "would purge sync tokens" + } else { + "purging sync tokens" + } + ); + + if !execute { + // For dry run mode, count tokens without deleting + match self.services.rooms.user.count_room_tokens(room_id).await { + | Ok(count) => + if count > 0 { + debug!("Would delete {} sync tokens for room {}", count, room_id); + total_tokens_deleted = total_tokens_deleted.saturating_add(count); + } else { + debug!("No sync tokens found for room {}", room_id); + }, + | Err(e) => { + debug!("Error counting sync tokens for room {}: {:?}", room_id, e); + error_count = error_count.saturating_add(1); + }, + } + } else { + // Real deletion mode + match self.services.rooms.user.delete_room_tokens(room_id).await { + | Ok(count) => + if count > 0 { + debug!("Deleted {} sync tokens for room {}", count, room_id); + total_tokens_deleted = total_tokens_deleted.saturating_add(count); + } else { + debug!("No sync tokens found for room {}", room_id); + }, + | Err(e) => { + debug!("Error purging sync tokens for room {}: {:?}", room_id, e); + error_count = error_count.saturating_add(1); + }, + } + } } - let action = if dry_run { "would be deleted" } else { "deleted" }; + let action = if !execute { "would be deleted" } else { "deleted" }; info!( - "Finished {}: processed {} empty rooms out of {} total, {} tokens {}, errors: {}", - if dry_run { + "Finished {}: checked {} rooms out of {} total, {} tokens {}, errors: {}", + if !execute { "purge simulation" } else { "purging sync tokens" }, - empty_rooms_processed, + total_rooms_checked, total_rooms, total_tokens_deleted, action, error_count ); - let mode_msg = if dry_run { "DRY RUN: " } else { "" }; self.write_str(&format!( - "{}Successfully processed {empty_rooms_processed} empty rooms (out of {total_rooms} \ - total rooms), {total_tokens_deleted} tokens {}. Skipped {skipped_rooms} rooms based on \ - filters. Failed for {error_count} rooms.", - mode_msg, - if dry_run { "would be deleted" } else { "deleted" } + "Finished {}: checked {} rooms out of {} total, {} tokens {}, errors: {}", + if !execute { "simulation" } else { "purging sync tokens" }, + total_rooms_checked, + total_rooms, + total_tokens_deleted, + action, + error_count )) .await } diff --git a/src/admin/room/mod.rs b/src/admin/room/mod.rs index 1b4650c3..fe44dec4 100644 --- a/src/admin/room/mod.rs +++ b/src/admin/room/mod.rs @@ -68,17 +68,14 @@ pub(super) enum RoomCommand { /// - Delete sync tokens for all rooms that have no local users /// /// By default, processes all empty rooms. - PurgeEmptyRoomTokens { - /// Confirm you want to delete tokens from potentially many rooms - #[arg(long)] - yes: bool, - + PurgeAllSyncTokens { /// Target specific room types #[arg(long, value_enum)] target_option: Option, - /// Perform a dry run without actually deleting any tokens + /// Execute token deletions. Otherwise, + /// Performs a dry run without actually deleting any tokens #[arg(long)] - dry_run: bool, + execute: bool, }, }