feat: gateway service

lib/libpk/Cargo.toml

@@ -17,6 +17,7 @@ tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-gelf = "0.7.1"
 tracing-subscriber = { workspace = true}
+twilight-model = { workspace = true }
 
 prost = { workspace = true }
 prost-types = { workspace = true }

lib/libpk/src/_config.rs

@@ -3,11 +3,23 @@ use lazy_static::lazy_static;
 use serde::Deserialize;
 use std::sync::Arc;
 
+use twilight_model::id::{marker::UserMarker, Id};
+
+#[derive(Clone, Deserialize, Debug)]
+pub struct ClusterSettings {
+    pub node_id: u32,
+    pub total_shards: u32,
+    pub total_nodes: u32,
+}
+
 #[derive(Deserialize, Debug)]
 pub struct DiscordConfig {
-    pub client_id: u32,
+    pub client_id: Id<UserMarker>,
     pub bot_token: String,
     pub client_secret: String,
+    pub max_concurrency: u32,
+    pub cluster: Option<ClusterSettings>,
+    pub api_base_url: Option<String>,
 }
 
 #[derive(Deserialize, Debug)]
@@ -41,6 +53,9 @@ pub struct ApiConfig {
 fn _metrics_default() -> bool {
     false
 }
+fn _json_log_default() -> bool {
+    false
+}
 
 #[derive(Deserialize, Debug)]
 pub struct PKConfig {
@@ -52,13 +67,20 @@ pub struct PKConfig {
     #[serde(default = "_metrics_default")]
     pub run_metrics_server: bool,
 
-    pub(crate) gelf_log_url: Option<String>,
+    #[serde(default = "_json_log_default")]
+    pub(crate) json_log: bool,
 }
 
 lazy_static! {
     #[derive(Debug)]
-    pub static ref CONFIG: Arc<PKConfig> = Arc::new(Config::builder()
-    .add_source(config::Environment::with_prefix("pluralkit").separator("__"))
-    .build().unwrap()
-    .try_deserialize::<PKConfig>().unwrap());
+    pub static ref CONFIG: Arc<PKConfig> = {
+        if let Ok(var) = std::env::var("NOMAD_ALLOC_INDEX") {
+            std::env::set_var("pluralkit__discord__cluster__node_id", var);
+        }
+
+        Arc::new(Config::builder()
+        .add_source(config::Environment::with_prefix("pluralkit").separator("__"))
+        .build().unwrap()
+        .try_deserialize::<PKConfig>().unwrap())
+    };
 }

lib/libpk/src/lib.rs

@@ -1,30 +1,24 @@
-use gethostname::gethostname;
 use metrics_exporter_prometheus::PrometheusBuilder;
-use tracing_subscriber::{prelude::__tracing_subscriber_SubscriberExt, EnvFilter, Registry};
+use tracing_subscriber::{EnvFilter, Registry};
 
 pub mod db;
 pub mod proto;
+pub mod util;
 
 pub mod _config;
 pub use crate::_config::CONFIG as config;
 
 pub fn init_logging(component: &str) -> anyhow::Result<()> {
-    let subscriber = Registry::default()
-        .with(EnvFilter::from_default_env())
-        .with(tracing_subscriber::fmt::layer());
-
-    if let Some(gelf_url) = &config.gelf_log_url {
-        let gelf_logger = tracing_gelf::Logger::builder()
-            .additional_field("component", component)
-            .additional_field("hostname", gethostname().to_str());
-        let mut conn_handle = gelf_logger
-            .init_udp_with_subscriber(gelf_url, subscriber)
-            .unwrap();
-        tokio::spawn(async move { conn_handle.connect().await });
+    // todo: fix component
+    if config.json_log {
+        tracing_subscriber::fmt()
+            .json()
+            .with_env_filter(EnvFilter::from_default_env())
+            .init();
     } else {
-        // gelf_logger internally sets the global subscriber
-        tracing::subscriber::set_global_default(subscriber)
-            .expect("unable to set global subscriber");
+        tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .init();
     }
 
     Ok(())

lib/libpk/src/util/mod.rs

@@ -0,0 +1 @@
+pub mod redis;

lib/libpk/src/util/redis.rs

@@ -0,0 +1,15 @@
+use fred::error::RedisError;
+
+pub trait RedisErrorExt<T> {
+    fn to_option_or_error(self) -> Result<Option<T>, RedisError>;
+}
+
+impl<T> RedisErrorExt<T> for Result<T, RedisError> {
+    fn to_option_or_error(self) -> Result<Option<T>, RedisError> {
+        match self {
+            Ok(v) => Ok(Some(v)),
+            Err(error) if error.is_not_found() => Ok(None),
+            Err(error) => Err(error),
+        }
+    }
+}