Merge refactor/once-cell into staging

src/event/event_repeater.rs

@@ -1,14 +1,12 @@
 use log::error;
 use std::{
     collections::HashMap,
-    sync::{Arc, Weak},
+    sync::{Arc, OnceLock, Weak},
 };
 use thiserror::Error;
 use tokio::{sync::Mutex, task::JoinHandle};
 use uuid::Uuid;
 
-use crate::setlock::{SetLock, SetLockError};
-
 use super::{Event, Subscription};
 
 #[derive(Debug, Error)]
@@ -53,7 +51,7 @@ where
     T: Send + Sync + 'static,
 {
     pub event: Event<T>,
-    weak: Mutex<SetLock<Weak<Self>>>,
+    weak: OnceLock<Weak<Self>>,
     subscriptions: Mutex<HashMap<Uuid, (Subscription, JoinHandle<()>)>>,
 }
 
@@ -68,25 +66,21 @@ where
     {
         let event = Event::new(name);
         let event_repeater = Self {
-            weak: Mutex::new(SetLock::new()),
+            weak: OnceLock::new(),
             event,
             subscriptions: Mutex::new(HashMap::new()),
         };
 
         let arc = Arc::new(event_repeater);
         let weak = Arc::downgrade(&arc);
 
-        let result = arc.weak.lock().await.set(weak);
-        if let Err(err) = result {
-            match err {
-                SetLockError::AlreadySet => {
-                    error!("Failed to set EventRepeater {}'s Weak self-reference because it was already set. This should never happen. Shutting down ungracefully to prevent further undefined behavior.", arc.event.name);
-                    unreachable!(
-                        "Unable to set EventRepeater {}'s Weak self-reference because it was already set.",
-                        arc.event.name
-                    );
-                }
-            }
+        let result = arc.weak.set(weak);
+        if result.is_err() {
+            error!("Failed to set EventRepeater {}'s Weak self-reference because it was already set. This should never happen. Shutting down ungracefully to prevent further undefined behavior.", arc.event.name);
+            unreachable!(
+                "Unable to set EventRepeater {}'s Weak self-reference because it was already set.",
+                arc.event.name
+            );
         }
 
         arc
@@ -97,8 +91,7 @@ where
     }
 
     pub async fn attach(&self, event: &Event<T>, buffer: usize) -> Result<(), AttachError> {
-        let lock = self.weak.lock().await;
-        let weak = match lock.get() {
+        let weak = match self.weak.get() {
             Some(weak) => weak,
             None => {
                 return Err(AttachError::NotInitialized {

src/lib.rs

@@ -8,7 +8,6 @@ pub mod config;
 pub mod event;
 pub mod log;
 pub mod service;
-pub mod setlock;
 
 pub fn is_debug() -> bool {
     cfg!(debug_assertions)

src/service/discord.rs

@@ -1,18 +1,19 @@
-use crate::setlock::SetLock;
-
 use super::{types::LifetimedPinnedBoxedFutureResult, Priority, Service, ServiceInfo, ServiceManager};
-use log::{error, info};
+use log::{error, info, warn};
 use serenity::{
     all::{GatewayIntents, Ready},
     async_trait,
     client::{self, Cache, Context},
     framework::{standard::Configuration, StandardFramework},
     gateway::{ShardManager, VoiceGatewayManager},
     http::Http,
     prelude::TypeMap,
     Client, Error,
 };
-use std::{sync::Arc, time::Duration};
+use std::{
+    sync::{Arc, OnceLock},
+    time::Duration,
+};
 use tokio::{
     select, spawn,
     sync::{Mutex, Notify, RwLock},
@@ -24,29 +25,29 @@
 pub struct DiscordService {
     info: ServiceInfo,
     discord_token: String,
-    pub ready: Arc<Mutex<SetLock<Ready>>>,
+    pub ready: Arc<OnceLock<Ready>>,
     client_handle: Option<JoinHandle<Result<(), Error>>>,
-    pub cache: SetLock<Arc<Cache>>,
-    pub data: SetLock<Arc<RwLock<TypeMap>>>,
-    pub http: SetLock<Arc<Http>>,
-    pub shard_manager: SetLock<Arc<ShardManager>>,
-    pub voice_manager: SetLock<Arc<dyn VoiceGatewayManager>>,
-    pub ws_url: SetLock<Arc<Mutex<String>>>,
+    pub cache: OnceLock<Arc<Cache>>,
+    pub data: OnceLock<Arc<RwLock<TypeMap>>>,
+    pub http: OnceLock<Arc<Http>>,
+    pub shard_manager: OnceLock<Arc<ShardManager>>,
+    pub voice_manager: OnceLock<Arc<dyn VoiceGatewayManager>>,
+    pub ws_url: OnceLock<Arc<Mutex<String>>>,
 }
 
 impl DiscordService {
     pub fn new(discord_token: &str) -> Self {
         Self {
             info: ServiceInfo::new("lum_builtin_discord", "Discord", Priority::Essential),
             discord_token: discord_token.to_string(),
-            ready: Arc::new(Mutex::new(SetLock::new())),
+            ready: Arc::new(OnceLock::new()),
             client_handle: None,
-            cache: SetLock::new(),
-            data: SetLock::new(),
-            http: SetLock::new(),
-            shard_manager: SetLock::new(),
-            voice_manager: SetLock::new(),
-            ws_url: SetLock::new(),
+            cache: OnceLock::new(),
+            data: OnceLock::new(),
+            http: OnceLock::new(),
+            shard_manager: OnceLock::new(),
+            voice_manager: OnceLock::new(),
+            ws_url: OnceLock::new(),
         }
     }
 }
@@ -60,8 +61,8 @@
         Box::pin(async move {
             let client_ready_notify = Arc::new(Notify::new());
 
             let framework = StandardFramework::new();
             framework.configure(Configuration::new().prefix("!"));
 
             let mut client = Client::builder(self.discord_token.as_str(), GatewayIntents::all())
                 .framework(framework)
@@ -71,30 +72,38 @@
                 ))
                 .await?;
 
-            if let Err(error) = self.cache.set(Arc::clone(&client.cache)) {
-                return Err(format!("Failed to set cache SetLock: {}", error).into());
+            if self.cache.set(Arc::clone(&client.cache)).is_err() {
+                error!("Could not set cache OnceLock because it was already set. This should never happen.");
+                return Err("Could not set cache OnceLock because it was already set.".into());
             }
 
-            if let Err(error) = self.data.set(Arc::clone(&client.data)) {
-                return Err(format!("Failed to set data SetLock: {}", error).into());
+            if self.data.set(Arc::clone(&client.data)).is_err() {
+                error!("Could not set data OnceLock because it was already set. This should never happen.");
+                return Err("Could not set data OnceLock because it was already set.".into());
             }
 
-            if let Err(error) = self.http.set(Arc::clone(&client.http)) {
-                return Err(format!("Failed to set http SetLock: {}", error).into());
+            if self.http.set(Arc::clone(&client.http)).is_err() {
+                error!("Could not set http OnceLock because it was already set. This should never happen.");
+                return Err("Could not set http OnceLock because it was already set.".into());
             }
 
-            if let Err(error) = self.shard_manager.set(Arc::clone(&client.shard_manager)) {
-                return Err(format!("Failed to set shard_manager SetLock: {}", error).into());
+            if self.shard_manager.set(Arc::clone(&client.shard_manager)).is_err() {
+                error!("Could not set shard_manager OnceLock because it was already set. This should never happen.");
+                return Err("Could not set shard_manager OnceLock because it was already set.".into());
             }
 
             if let Some(voice_manager) = &client.voice_manager {
-                if let Err(error) = self.voice_manager.set(Arc::clone(voice_manager)) {
-                    return Err(format!("Failed to set voice_manager SetLock: {}", error).into());
+                if self.voice_manager.set(Arc::clone(voice_manager)).is_err() {
+                    error!("Could not set voice_manager OnceLock because it was already set. This should never happen.");
+                    return Err("Could not set voice_manager OnceLock because it was already set.".into());
                 }
+            } else {
+                warn!("Voice manager is not available");
             }
 
-            if let Err(error) = self.ws_url.set(Arc::clone(&client.ws_url)) {
-                return Err(format!("Failed to set ws_url SetLock: {}", error).into());
+            if self.ws_url.set(Arc::clone(&client.ws_url)).is_err() {
+                error!("Could not set ws_url OnceLock because it was already set. This should never happen.");
+                return Err("Could not set ws_url OnceLock because it was already set.".into());
             }
 
             let client_handle = spawn(async move { client.start().await });
@@ -138,12 +147,12 @@
 }
 
 struct EventHandler {
-    client: Arc<Mutex<SetLock<Ready>>>,
+    client: Arc<OnceLock<Ready>>,
     ready_notify: Arc<Notify>,
 }
 
 impl EventHandler {
-    pub fn new(client: Arc<Mutex<SetLock<Ready>>>, ready_notify: Arc<Notify>) -> Self {
+    pub fn new(client: Arc<OnceLock<Ready>>, ready_notify: Arc<Notify>) -> Self {
         Self { client, ready_notify }
     }
 }
@@ -152,9 +161,9 @@
 impl client::EventHandler for EventHandler {
     async fn ready(&self, _ctx: Context, data_about_bot: Ready) {
         info!("Connected to Discord as {}", data_about_bot.user.tag());
-        if let Err(error) = self.client.lock().await.set(data_about_bot) {
-            error!("Failed to set client SetLock: {}", error);
-            panic!("Failed to set client SetLock: {}", error);
+        if self.client.set(data_about_bot).is_err() {
+            error!("Could not set client OnceLock because it was already set. This should never happen.");
+            panic!("Could not set client OnceLock because it was already set");
         }
         self.ready_notify.notify_one();
     }