Wipe out parking_lot

Author: tazz4843

Cargo.lock

@@ -87,7 +87,6 @@ serde_json = "1"
 systemstat = "0.2"
 num-format = "0.4"
 async-trait = "0.1"
-parking_lot = "0.12"
 unic-langid = "0.9"
 dasp_signal = "0.11"
 serde_derive = "1"
@@ -112,7 +111,7 @@ audiopus_sys = { version = "0.2", features = ["static"] }
 tokio-metrics = { version = "0.4", features = ["rt"] }
 async-tempfile = { version = "0.7", features = ["uuid"] }
 dasp_interpolate = { version = "0.11", features = ["linear"] }
-tokio = { version = "1", features = ["parking_lot", "signal", "rt-multi-thread"] }
+tokio = { version = "1", features = ["signal", "rt-multi-thread"] }
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
 sqlx = { version = "0.8", features = ["postgres", "macros", "migrate", "runtime-tokio-rustls", "time"] }
 

Cargo.toml

@@ -20,7 +20,6 @@ songbird.workspace = true
 serenity.workspace = true
 backtrace.workspace = true
 async-trait.workspace = true
-parking_lot.workspace = true
 
 scripty_db = { path = "../scripty_db" }
 scripty_stt = { path = "../scripty_stt" }

scripty_audio_handler/Cargo.toml

@@ -2,13 +2,13 @@ use std::{
 	collections::VecDeque,
 	sync::{
 		Arc,
+		RwLock,
 		atomic::{AtomicBool, AtomicU8, Ordering},
 	},
 };
 
 use ahash::RandomState;
 use dashmap::{DashMap, DashSet};
-use parking_lot::RwLock;
 use scripty_automod::types::AutomodServerConfig;
 use scripty_data_type::{CallDeath, get_data};
 use scripty_integrations::kiai::KiaiApiClient;
@@ -225,8 +225,20 @@ impl AudioHandler {
 		self.kiai_enabled
 			.store(guild_res.kiai_enabled, Ordering::Relaxed);
 
-		std::mem::swap(&mut *self.language.write(), &mut guild_res.language);
-		*self.transcribe_only_role.write() = guild_res
+		std::mem::swap(
+			&mut *self.language.write().unwrap_or_else(|poisoned| {
+				warn!(%self.guild_id, "language was poisoned");
+				poisoned.into_inner()
+			}),
+			&mut guild_res.language,
+		);
+		*self
+			.transcribe_only_role
+			.write()
+			.unwrap_or_else(|poisoned| {
+				warn!(%self.guild_id, "language was poisoned");
+				poisoned.into_inner()
+			}) = guild_res
 			.transcript_only_role
 			.map(|x| RoleId::new(x as u64));
 
@@ -244,7 +256,10 @@ impl EventHandler for AudioHandler {
 				Arc::clone(&self.ssrc_state),
 				self.seen_users.clone(),
 				self.guild_id,
-				*self.transcribe_only_role.read(),
+				*self.transcribe_only_role.read().unwrap_or_else(|poisoned| {
+					warn!("transcribe only role is poisoned");
+					poisoned.into_inner()
+				}),
 			)),
 			EventContext::VoiceTick(voice_data) => tokio::spawn(voice_tick(VoiceTickContext {
 				voice_data:         voice_data.clone(),

scripty_audio_handler/src/audio_handler.rs

@@ -63,7 +63,15 @@ pub async fn client_disconnect(
 		&& ssrc_state.active_user_set.len() < max_users
 	{
 		debug!(?ssrc, "there is space for another active user");
-		if let Some(next) = ssrc_state.next_user_list.write().pop_front() {
+		if let Some(next) = ssrc_state
+			.next_user_list
+			.write()
+			.unwrap_or_else(|poisoned| {
+				warn!("next user list is poisoned");
+				poisoned.into_inner()
+			})
+			.pop_front()
+		{
 			debug!(?ssrc, "inserting new user into map");
 			ssrc_state.active_user_set.insert(next);
 		}
@@ -81,7 +89,12 @@ pub async fn client_disconnect(
 	}
 
 	if let Some(transcript_results) = transcript_results {
-		let mut transcript_results = transcript_results.write();
-		transcript_results.push(format!("[{}] - event: disconnected", username));
+		transcript_results
+			.write()
+			.unwrap_or_else(|poisoned| {
+				warn!("transcript results are poisoned");
+				poisoned.into_inner()
+			})
+			.push(format!("[{}] - event: disconnected", username));
 	}
 }

scripty_audio_handler/src/events/client_disconnect.rs

@@ -148,7 +148,16 @@ pub async fn driver_disconnect(
 
 	// send all users the results of their transcriptions
 	if let (Some(transcript_results), Some(seen_users)) = (transcript_results, seen_users) {
-		let final_text_output = transcript_results.read().join("\n");
+		let final_text_output = transcript_results
+			.read()
+			.unwrap_or_else(|poisoned| {
+				warn!(
+					%guild_id,
+					"transcript results poisoned, may be inconsistent"
+				);
+				poisoned.into_inner()
+			})
+			.join("\n");
 		let attachment = CreateAttachment::bytes(final_text_output.into_bytes(), "transcript.txt");
 		let message = CreateMessage::new().add_file(attachment.clone()).content(
 			"This transcript was automatically sent to all users who spoke in the voice chat.",

scripty_audio_handler/src/events/driver_disconnect.rs

@@ -2,14 +2,14 @@ use std::{
 	borrow::Cow,
 	sync::{
 		Arc,
+		RwLock,
 		atomic::{AtomicBool, Ordering},
 	},
 	time::Instant,
 };
 
 use ahash::RandomState;
 use dashmap::DashSet;
-use parking_lot::RwLock;
 use scripty_automod::types::{AutomodRuleAction, AutomodServerConfig};
 use scripty_integrations::kiai::{KiaiApiClient, KiaiPostVirtualMessage};
 use scripty_metrics::Metrics;
@@ -172,7 +172,13 @@ async fn handle_silent_speakers<'a>(
 		};
 
 		// finalize the stream
-		let lang = language.read().clone();
+		let lang = language
+			.read()
+			.unwrap_or_else(|poisoned| {
+				warn!(%guild_id, "language is poisoned");
+				poisoned.into_inner()
+			})
+			.clone();
 		let _typing = thread_id
 			.map_or_else(|| channel_id.widen(), ThreadId::widen)
 			.start_typing(ctx.http.clone());
@@ -288,7 +294,13 @@ async fn handle_silent_speakers<'a>(
 					let username = &user_details.0;
 					format!("[{}]: {}", username, final_result)
 				};
-				transcript_results.write().push(fmt_transcript);
+				transcript_results
+					.write()
+					.unwrap_or_else(|poisoned| {
+						warn!(%guild_id, "transcript results are poisoned");
+						poisoned.into_inner()
+					})
+					.push(fmt_transcript);
 			}
 		}
 

scripty_audio_handler/src/events/voice_tick.rs

@@ -1,3 +1,4 @@
+#![deny(clippy::unwrap_used, clippy::expect_used)]
 #![feature(let_chains)]
 #[macro_use]
 extern crate tracing;
@@ -40,13 +41,16 @@ pub async fn get_voice_channel_id(guild_id: GuildId) -> Option<ChannelId> {
 }
 
 pub fn set_songbird(sb: Arc<Songbird>) {
-	SONGBIRD
-		.set(sb)
-		.expect("should not call set_songbird more than once");
+	if SONGBIRD.set(sb).is_err() {
+		warn!("set_songbird was called more than once");
+	}
 }
 
 pub fn get_songbird() -> Arc<Songbird> {
-	SONGBIRD.get().expect("songbird not registered").clone()
+	match SONGBIRD.get() {
+		Some(sb) => sb.clone(),
+		None => panic!("you must set get_songbird before calling get_songbird"),
+	}
 }
 
 static AUTO_LEAVE_TASKS: OnceCell<DashMap<GuildId, Sender<()>, ahash::RandomState>> =
@@ -110,6 +114,15 @@ pub fn get_internal_state(guild_id: &GuildId) -> Option<InternalSsrcStateDetails
 			.collect(),
 		ssrcs_actively_speaking_this_tick: v.ssrc_speaking_set.iter().map(|x| *x).collect(),
 		actively_transcribed_ssrcs: v.active_user_set.iter().map(|x| *x).collect(),
-		next_ssrcs: v.next_user_list.read().iter().copied().collect(),
+		next_ssrcs: v
+			.next_user_list
+			.read()
+			.unwrap_or_else(|poisoned| {
+				warn!("next ssrc list is poisoned");
+				poisoned.into_inner()
+			})
+			.iter()
+			.copied()
+			.collect(),
 	})
 }

scripty_audio_handler/src/lib.rs

@@ -1,8 +1,10 @@
-use std::{collections::VecDeque, sync::Arc};
+use std::{
+	collections::VecDeque,
+	sync::{Arc, RwLock},
+};
 
 use ahash::RandomState;
 use dashmap::{DashMap, DashSet};
-use parking_lot::RwLock;
 use scripty_data_storage::VoiceIngest;
 use scripty_stt::Stream;
 

scripty_audio_handler/src/types.rs

@@ -20,28 +20,25 @@ pub async fn entrypoint() {
 	// fetch the config
 	let cfg = scripty_config::get_config();
 
-	// initialize the blocked entity list
-	info!("fetching blocked entities");
-	scripty_bot_utils::entity_block::init_blocked()
-		.await
-		.expect("failed to init blocked entities");
-
 	// initialize the framework
+	info!("loading framework");
 	let framework = FrameworkBuilder::default()
 		.options(framework_opts::get_framework_opts())
 		.build();
+	info!("setting global data");
 	let data = Arc::new(Data::new());
 	if CLIENT_DATA.set(data.clone()).is_err() {
 		unreachable!("client data set more than once: bug?")
 	}
 
+	info!("initializing songbird");
 	let songbird = scripty_audio_handler::Songbird::serenity_from_config(
 		scripty_audio_handler::get_songbird_config(),
 	);
 	scripty_audio_handler::set_songbird(songbird.clone());
 
+	info!("initializing HTTP client");
 	let token = Token::from_str(&cfg.tokens.discord).expect("failed to parse token");
-
 	let mut http = serenity::http::HttpBuilder::new(token.clone());
 	if let Some(proxy) = &cfg.proxy {
 		http = http.proxy(proxy).ratelimiter_disabled(true);
@@ -51,6 +48,7 @@ pub async fn entrypoint() {
 		ratelimiter.set_ratelimit_callback(Box::new(handler::ratelimit));
 	}
 
+	info!("building serenity client");
 	let mut client =
 		ClientBuilder::new_with_http(token, Arc::new(http), framework_opts::get_gateway_intents())
 			.compression(TransportCompression::None)
@@ -68,5 +66,6 @@ pub async fn entrypoint() {
 		.set(client.shard_manager.runners.clone())
 		.expect("no other task should set shard manager");
 
+	info!("starting scripty");
 	client.start_autosharded().await.expect("failed to run bot");
 }