refactor: remove protobuf

services/api/Cargo.toml

@@ -10,7 +10,6 @@ fred = { workspace = true }
 lazy_static = { workspace = true }
 libpk = { path = "../../lib/libpk" }
 metrics = { workspace = true }
-prost = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 sqlx = { workspace = true }

services/api/src/endpoints/private.rs

@@ -1,8 +1,7 @@
 use crate::ApiContext;
 use axum::{extract::State, response::Json};
 use fred::interfaces::*;
-use libpk::proto::ShardState;
-use prost::Message;
+use libpk::state::ShardState;
 use serde::Deserialize;
 use serde_json::{json, Value};
 use std::collections::HashMap;
@@ -14,16 +13,22 @@ struct ClusterStats {
     pub channel_count: i32,
 }
 
-pub async fn meta(State(ctx): State<ApiContext>) -> Json<Value> {
+pub async fn discord_state(State(ctx): State<ApiContext>) -> Json<Value> {
     let shard_status = ctx
         .redis
-        .hgetall::<HashMap<String, Vec<u8>>, &str>("pluralkit:shardstatus")
+        .hgetall::<HashMap<String, String>, &str>("pluralkit:shardstatus")
         .await
         .unwrap()
         .values()
-        .map(|v| ShardState::decode(v.as_slice()).unwrap())
+        .map(|v| serde_json::from_str(v).expect("could not deserialize shard"))
         .collect::<Vec<ShardState>>();
 
+    Json(json!({
+        "shards": shard_status,
+    }))
+}
+
+pub async fn meta(State(ctx): State<ApiContext>) -> Json<Value> {
     let cluster_stats = ctx
         .redis
         .hgetall::<HashMap<String, String>, &str>("pluralkit:cluster_stats")
@@ -39,15 +44,12 @@ pub async fn meta(State(ctx): State<ApiContext>) -> Json<Value> {
     let channel_count: i32 = cluster_stats.iter().map(|v| v.channel_count).sum();
 
     Json(json!({
-        "shards": shard_status,
-        "stats": {
-            "system_count": db_stats.system_count,
-            "member_count": db_stats.member_count,
-            "group_count": db_stats.group_count,
-            "switch_count": db_stats.switch_count,
-            "message_count": db_stats.message_count,
-            "guild_count": guild_count,
-            "channel_count": channel_count,
-        }
+        "system_count": db_stats.system_count,
+        "member_count": db_stats.member_count,
+        "group_count": db_stats.group_count,
+        "switch_count": db_stats.switch_count,
+        "message_count": db_stats.message_count,
+        "guild_count": guild_count,
+        "channel_count": channel_count,
     }))
 }

services/api/src/main.rs

@@ -104,10 +104,11 @@ fn router(ctx: ApiContext) -> Router {
 
         .route("/v2/messages/:message_id", get(rproxy))
 
-        .route("/private/meta", get(endpoints::private::meta))
         .route("/private/bulk_privacy/member", post(rproxy))
         .route("/private/bulk_privacy/group", post(rproxy))
         .route("/private/discord/callback", post(rproxy))
+        .route("/private/discord/shard_state", get(endpoints::private::discord_state))
+        .route("/private/stats", get(endpoints::private::meta))
 
         .route("/v2/systems/:system_id/oembed.json", get(rproxy))
         .route("/v2/members/:member_id/oembed.json", get(rproxy))

services/api/src/middleware/logger.rs

@@ -42,7 +42,6 @@ pub async fn logger(request: Request, next: Next) -> Response {
 
     let authenticated = {
         let headers = response.headers_mut();
-        println!("{:#?}", headers.keys());
         if headers.contains_key(DID_AUTHENTICATE_HEADER) {
             headers.remove(DID_AUTHENTICATE_HEADER);
             true

services/gateway/Cargo.toml

@@ -13,7 +13,6 @@ futures = { workspace = true }
 lazy_static = { workspace = true }
 libpk = { path = "../../lib/libpk" }
 metrics = { workspace = true }
-prost = { workspace = true }
 serde_json = { workspace = true }
 signal-hook = { workspace = true }
 tokio = { workspace = true }

services/gateway/src/discord/shard_state.rs

@@ -1,11 +1,10 @@
 use bytes::Bytes;
 use fred::{clients::RedisPool, interfaces::HashesInterface};
 use metrics::{counter, gauge};
-use prost::Message;
 use tracing::info;
 use twilight_gateway::Event;
 
-use libpk::{proto::*, util::redis::*};
+use libpk::{state::*, util::redis::*};
 
 #[derive(Clone)]
 pub struct ShardStateManager {
@@ -28,26 +27,24 @@ impl ShardStateManager {
     }
 
     async fn get_shard(&self, shard_id: u32) -> anyhow::Result<ShardState> {
-        let data: Option<Vec<u8>> = self
+        let data: Option<String> = self
             .redis
             .hget("pluralkit:shardstatus", shard_id)
             .await
             .to_option_or_error()?;
         match data {
-            Some(buf) => {
-                Ok(ShardState::decode(buf.as_slice()).expect("could not decode shard data!"))
-            }
+            Some(buf) => Ok(serde_json::from_str(&buf).expect("could not decode shard data!")),
             None => Ok(ShardState::default()),
         }
     }
 
     async fn save_shard(&self, shard_id: u32, info: ShardState) -> anyhow::Result<()> {
         self.redis
-            .hset::<(), &str, (String, Bytes)>(
+            .hset::<(), &str, (String, String)>(
                 "pluralkit:shardstatus",
                 (
                     shard_id.to_string(),
-                    Bytes::copy_from_slice(&info.encode_to_vec()),
+                    serde_json::to_string(&info).expect("could not serialize shard"),
                 ),
             )
             .await?;