feat: config file support

Author: user0-07161

Cargo.lock

@@ -13,6 +13,8 @@ tracing = "0.1.41"
 tracing-subscriber = "0.3.20"
 thiserror = "2.0.17"
 anyhow = "1.0.100"
+toml = "0.9.7"
+serde = { version = "1.0.228", features = ["derive"] }
 
 [features]
 tokio-console = ["tokio/tracing", "console-subscriber"]

Cargo.toml

@@ -0,0 +1,5 @@
+ip = "0.0.0.0"
+port = 6667
+server_hostname = "irc.foo.bar"
+network_name = "MyCoolFooNet" # this SHOULDN'T HAVE SPACES!
+operators = []

examples/example_config.toml

@@ -0,0 +1,52 @@
+use std::{env::home_dir, fs::read_to_string, path::PathBuf};
+
+use crate::error_structs::ConfigReadError;
+use serde::Deserialize;
+
+#[allow(dead_code)]
+#[derive(Clone, Debug, Deserialize)]
+pub struct ServerInfo {
+    pub ip: String,
+    pub port: u64,
+    pub server_hostname: String,
+    pub network_name: String,
+    pub operators: Vec<String>,
+}
+
+fn get_config_path() -> Result<PathBuf, ConfigReadError> {
+    if cfg!(target_os = "linux") {
+        if let Some(mut homedir) = home_dir() {
+            homedir.push(".config");
+            homedir.push("irs");
+            homedir.push("config.toml");
+
+            if homedir.exists() {
+                return Ok(homedir);
+            }
+        }
+
+        let dir = PathBuf::from("/etc/irs/config.toml");
+        if dir.exists() {
+            dir
+        } else {
+            return Err(ConfigReadError::NoConfigFile);
+        }
+    } else {
+        return Err(ConfigReadError::UnsupportedOS);
+    };
+
+    unreachable!()
+}
+
+impl ServerInfo {
+    pub fn load(path: Option<String>) -> Result<Self, ConfigReadError> {
+        let path = if let Some(path) = path {
+            PathBuf::from(path)
+        } else {
+            get_config_path()?
+        };
+        let config: ServerInfo = toml::from_str(&read_to_string(path)?)?;
+
+        Ok(config)
+    }
+}

src/config.rs

@@ -27,6 +27,21 @@ pub enum CommandExecError {
     NonexistantCommand,
 }
 
+#[derive(Error, Debug)]
+pub enum ConfigReadError {
+    #[error("could not find a config file")]
+    NoConfigFile,
+
+    #[error("unsupported OS")]
+    UnsupportedOS,
+
+    #[error("std::io error")]
+    StdIoError(#[from] std::io::Error),
+
+    #[error("toml reading error")]
+    TomlError(#[from] toml::de::Error),
+}
+
 // Conversion impls here
 impl From<SenderError> for ListenerError {
     fn from(value: SenderError) -> Self {

src/error_structs.rs

@@ -6,6 +6,7 @@ use std::{
 };
 
 use anyhow::Error as AnyhowError;
+use clap::Parser;
 use once_cell::sync::Lazy;
 use tokio::{
     io::{AsyncBufReadExt, BufReader as TokioBufReader, BufWriter as TokioBufWriter},
@@ -21,6 +22,7 @@ use tracing::instrument;
 
 use crate::{
     channels::Channel,
+    config::ServerInfo,
     error_structs::{HandlerError, ListenerError},
     login::send_motd,
     messages::Message,
@@ -30,6 +32,7 @@ use crate::{
 
 mod channels;
 mod commands;
+mod config;
 mod error_structs;
 mod login;
 mod messages;
@@ -42,28 +45,21 @@ pub static JOINED_CHANNELS: Lazy<Mutex<HashSet<Channel>>> =
     Lazy::new(|| Mutex::new(HashSet::new()));
 pub static SENDER: Lazy<Mutex<Option<Sender<Message>>>> = Lazy::new(|| Mutex::new(None));
 
-#[allow(dead_code)]
-#[derive(Clone, Debug)]
-struct ServerInfo {
-    ip: String,
-    port: String,
-    server_hostname: String,
-    network_name: String,
-    operators: Vec<String>,
+/// An IRCd written in Rust
+#[derive(Parser, Debug)]
+struct Args {
+    /// Path to the config file
+    #[arg(short, long)]
+    pub config_path: Option<String>,
 }
 
 #[tokio::main]
 async fn main() -> Result<(), AnyhowError> {
     #[cfg(feature = "tokio-console")]
     console_subscriber::init();
 
-    let info = ServerInfo {
-        ip: "0.0.0.0".into(),
-        port: "6667".into(),
-        server_hostname: "irc.blah.blah".into(),
-        network_name: "TeamDunno".into(),
-        operators: Vec::new(),
-    };
+    let args = Args::parse();
+    let info = ServerInfo::load(args.config_path).unwrap();
     // TODO: ^ pull these from a config file
 
     let listener = TcpListener::bind(SocketAddr::from_str(&format!("{}:{}", info.ip, info.port))?)?;