feat(playmatch): persist suggestion cards in Redis across restarts

Author: DevYukine

Cargo.lock

@@ -30,6 +30,7 @@ poise = { git = "https://github.com/serenity-rs/poise", branch = "serenity-next"
 # playmatch
 playmatch_client = { path = "playmatch_client" }
 governor = "^0.10"
+redis = { version = "^1.0", features = ["tokio-comp", "connection-manager"] }
 
 # commands
 unicode-width = "^0.2"

Cargo.toml

@@ -42,6 +42,7 @@ Every response is rendered with Discord's Components V2 (top-level `Container`,
 | `DISCORD_TOKEN` | yes | Bot token from the Discord Developer Portal |
 | `PLAYMATCH_API_AUTH` | yes | Bearer token for the Playmatch API |
 | `PLAYMATCH_API_URL` | no | Playmatch base URL, defaults to `https://playmatch.retrorealm.dev` |
+| `REDIS_URL` | yes | Redis connection string (e.g. `redis://localhost:6379`), used to persist posted suggestion cards across restarts |
 | `DISCORD_STATUS` | no | Activity kind (`playing`, `listening`, `watching`, `competing`) |
 | `DISCORD_STATUS_NAME` | no | Activity text shown next to the kind |
 | `DISCORD_RETROREALM_SERVER_ID` | for guild commands | Guild id used when registering guild-scoped commands |

README.md

@@ -18,10 +18,11 @@ pub type CheckResult = Result<bool, CommandError>;
 pub struct CommandData {
 	pub client: reqwest::Client,
 	pub playmatch_client: Arc<crate::abstraction::playmatch_client::PlaymatchClient>,
+	pub suggestion_store: Arc<crate::abstraction::suggestion_store::SuggestionStore>,
 }
 
-impl Default for CommandData {
-	fn default() -> Self {
+impl CommandData {
+	pub async fn new() -> anyhow::Result<Self> {
 		let mut headers = HeaderMap::new();
 		headers.insert(
 			"Authorization",
@@ -50,12 +51,17 @@ impl Default for CommandData {
 			client.clone(),
 		);
 
-		Self {
+		let redis_url = env::var("REDIS_URL").expect("missing REDIS_URL");
+		let suggestion_store =
+			crate::abstraction::suggestion_store::SuggestionStore::connect(&redis_url).await?;
+
+		Ok(Self {
 			client,
 			playmatch_client: Arc::new(crate::abstraction::playmatch_client::PlaymatchClient::new(
 				inner,
 			)),
-		}
+			suggestion_store: Arc::new(suggestion_store),
+		})
 	}
 }
 

src/abstraction/command.rs

@@ -4,3 +4,4 @@ pub mod components_v2;
 pub mod playmatch;
 pub mod playmatch_client;
 pub mod providers;
+pub mod suggestion_store;

src/abstraction/mod.rs

@@ -0,0 +1,91 @@
+use std::collections::HashMap;
+use std::str::FromStr;
+
+use redis::AsyncCommands;
+use redis::aio::ConnectionManager;
+use serenity::all::MessageId;
+use uuid::Uuid;
+
+pub type Error = redis::RedisError;
+
+const KEY_PREFIX: &str = "playmatch:suggestion:";
+
+fn key_for(uuid: Uuid) -> String {
+	format!("{KEY_PREFIX}{uuid}")
+}
+
+/// Persistent map of suggestion UUID → Discord message id. Backed by Redis so the bot
+/// can restart without re-posting cards or losing track of already-posted ones.
+pub struct SuggestionStore {
+	conn: ConnectionManager,
+}
+
+impl SuggestionStore {
+	pub async fn connect(url: &str) -> Result<Self, Error> {
+		let client = redis::Client::open(url)?;
+		let conn = ConnectionManager::new(client).await?;
+		Ok(Self { conn })
+	}
+
+	pub async fn mark_posted(&self, uuid: Uuid, message_id: MessageId) -> Result<(), Error> {
+		let mut c = self.conn.clone();
+		c.set::<_, _, ()>(key_for(uuid), message_id.get()).await
+	}
+
+	pub async fn get(&self, uuid: Uuid) -> Result<Option<MessageId>, Error> {
+		let mut c = self.conn.clone();
+		let raw: Option<u64> = c.get(key_for(uuid)).await?;
+		Ok(raw.map(MessageId::new))
+	}
+
+	pub async fn remove(&self, uuid: Uuid) -> Result<(), Error> {
+		let mut c = self.conn.clone();
+		c.del::<_, ()>(key_for(uuid)).await
+	}
+
+	pub async fn list_all(&self) -> Result<HashMap<Uuid, MessageId>, Error> {
+		let mut conn = self.conn.clone();
+		let pattern = format!("{KEY_PREFIX}*");
+		let mut cursor = 0u64;
+		let mut keys: Vec<String> = Vec::new();
+		loop {
+			let (next_cursor, batch): (u64, Vec<String>) = redis::cmd("SCAN")
+				.arg(cursor)
+				.arg("MATCH")
+				.arg(&pattern)
+				.arg("COUNT")
+				.arg(100)
+				.query_async(&mut conn)
+				.await?;
+			keys.extend(batch);
+			if next_cursor == 0 {
+				break;
+			}
+			cursor = next_cursor;
+		}
+
+		if keys.is_empty() {
+			return Ok(HashMap::new());
+		}
+
+		let values: Vec<Option<u64>> = conn.mget(&keys).await?;
+		let mut result = HashMap::with_capacity(keys.len());
+		for (key, value) in keys.into_iter().zip(values) {
+			let Some(uuid_str) = key.strip_prefix(KEY_PREFIX) else {
+				continue;
+			};
+			let Ok(uuid) = Uuid::from_str(uuid_str) else {
+				continue;
+			};
+			let Some(message_id) = value else {
+				continue;
+			};
+			result.insert(uuid, MessageId::new(message_id));
+		}
+		Ok(result)
+	}
+
+	pub async fn is_empty(&self) -> Result<bool, Error> {
+		Ok(self.list_all().await?.is_empty())
+	}
+}