chore: clean up some rust code

crates/api/src/endpoints/private.rs

@@ -83,8 +83,8 @@ pub async fn discord_callback(
         .expect("error making client");
 
     let reqbody = serde_urlencoded::to_string(&CallbackDiscordData {
-        client_id: config.discord.as_ref().unwrap().client_id.get().to_string(),
-        client_secret: config.discord.as_ref().unwrap().client_secret.clone(),
+        client_id: config.discord().client_id.get().to_string(),
+        client_secret: config.discord().client_secret.clone(),
         grant_type: "authorization_code".to_string(),
         redirect_uri: request_data.redirect_domain, // change this!
         code: request_data.code,

crates/api/src/main.rs

@@ -11,7 +11,8 @@ use hyper_util::{
     client::legacy::{Client, connect::HttpConnector},
     rt::TokioExecutor,
 };
-use tracing::info;
+use libpk::config;
+use tracing::{info, warn};
 
 use pk_macros::api_endpoint;
 
@@ -128,7 +129,15 @@ fn router(ctx: ApiContext) -> Router {
         .route("/v2/members/{member_id}/oembed.json", get(rproxy))
         .route("/v2/groups/{group_id}/oembed.json", get(rproxy))
 
-        .layer(middleware::ratelimit::ratelimiter(middleware::ratelimit::do_request_ratelimited)) // this sucks
+        .layer(axum::middleware::from_fn_with_state(
+            if config.api().use_ratelimiter {
+                Some(ctx.redis.clone())
+            } else {
+                warn!("running without request rate limiting!");
+                None
+            },
+            middleware::ratelimit::do_request_ratelimited)
+        )
         .layer(axum::middleware::from_fn(middleware::ignore_invalid_routes::ignore_invalid_routes))
         .layer(axum::middleware::from_fn_with_state(ctx.clone(), middleware::params::params))
         .layer(axum::middleware::from_fn_with_state(ctx.clone(), middleware::auth::auth))
@@ -146,14 +155,7 @@ async fn main() -> anyhow::Result<()> {
     let db = libpk::db::init_data_db().await?;
     let redis = libpk::db::init_redis().await?;
 
-    let rproxy_uri = Uri::from_static(
-        &libpk::config
-            .api
-            .as_ref()
-            .expect("missing api config")
-            .remote_url,
-    )
-    .to_string();
+    let rproxy_uri = Uri::from_static(&libpk::config.api().remote_url).to_string();
     let rproxy_client = hyper_util::client::legacy::Client::<(), ()>::builder(TokioExecutor::new())
         .build(HttpConnector::new());
 
@@ -167,12 +169,7 @@ async fn main() -> anyhow::Result<()> {
 
     let app = router(ctx);
 
-    let addr: &str = libpk::config
-        .api
-        .as_ref()
-        .expect("missing api config")
-        .addr
-        .as_ref();
+    let addr: &str = libpk::config.api().addr.as_ref();
 
     let listener = tokio::net::TcpListener::bind(addr).await?;
     info!("listening on {}", addr);

crates/api/src/middleware/auth.rs

@@ -44,12 +44,7 @@ pub async fn auth(State(ctx): State<ApiContext>, mut req: Request, next: Next) -
         .get("x-pluralkit-app")
         .map(|h| h.to_str().ok())
         .flatten()
-        && let Some(config_token2) = libpk::config
-            .api
-            .as_ref()
-            .expect("missing api config")
-            .temp_token2
-            .as_ref()
+        && let Some(config_token2) = libpk::config.api().temp_token2.as_ref()
         && app_auth_header
             .as_bytes()
             .ct_eq(config_token2.as_bytes())

crates/api/src/middleware/ratelimit.rs

@@ -3,12 +3,12 @@ use std::time::{Duration, SystemTime};
 use axum::{
     extract::{MatchedPath, Request, State},
     http::{HeaderValue, Method, StatusCode},
-    middleware::{FromFnLayer, Next},
+    middleware::Next,
     response::Response,
 };
-use fred::{clients::RedisPool, interfaces::ClientLike, prelude::LuaInterface, util::sha1_hash};
+use fred::{clients::RedisPool, prelude::LuaInterface, util::sha1_hash};
 use metrics::counter;
-use tracing::{debug, error, info, warn};
+use tracing::{debug, error, info};
 
 use crate::{
     auth::AuthState,
@@ -21,40 +21,6 @@ lazy_static::lazy_static! {
     static ref LUA_SCRIPT_SHA: String = sha1_hash(LUA_SCRIPT);
 }
 
-// this is awful but it works
-pub fn ratelimiter<F, T>(f: F) -> FromFnLayer<F, Option<RedisPool>, T> {
-    let redis = libpk::config
-        .api
-        .as_ref()
-        .expect("missing api config")
-        .ratelimit_redis_addr
-        .as_ref()
-        .map(|val| {
-            // todo: this should probably use the global pool
-            let r = RedisPool::new(
-                fred::types::RedisConfig::from_url_centralized(val.as_ref())
-                    .expect("redis url is invalid"),
-                None,
-                None,
-                Some(Default::default()),
-                10,
-            )
-            .expect("failed to connect to redis");
-
-            let handle = r.connect();
-
-            tokio::spawn(async move { handle });
-
-            r
-        });
-
-    if redis.is_none() {
-        warn!("running without request rate limiting!");
-    }
-
-    axum::middleware::from_fn_with_state(redis, f)
-}
-
 enum RatelimitType {
     GenericGet,
     GenericUpdate,