Merge pull request 'type-api-rewrite' (#1) from type-api-rewrite into main

Reviewed-on: #1

.gitignore

@@ -1,2 +1,3 @@
 /target
-.env
+.env
+config.json

Cargo.toml

@@ -1,16 +1,14 @@
 [package]
 name = "playerbot"
-version = "0.6.1"
+version = "1.0.0"
 edition = "2021"
 
 [dependencies]
-anyhow = "1.0.93"
+anyhow = "1.0.102"
-dotenvy = "0.15.7"
+futures = "0.3.32"
-log = "0.4.22"
+poise = "0.6.2"
-poise = "0.6.1"
+reqwest = {version = "0.13.3", features = ["json"]}
-pretty_env_logger = "0.5.0"
-reqwest = {version = "0.12.9", features = ["json"]}
 serde = {version = "1.0.215", features = ["derive", "serde_derive"]}
-serde_json = {version = "1.0.132", features = []}
+serde_json = "1.0.149"
 tokio = {version = "1.41.1", features = ["full"]}
 url = "2.5.3"

src/bot_runner.rs

@@ -0,0 +1,135 @@
+
+
+use crate::request::request;
+use crate::types::*;
+use poise::serenity_prelude as serenity;
+use poise::serenity_prelude::{ActivityData, ClientBuilder, GatewayIntents};
+use tokio::sync::Mutex;
+
+pub struct BotRunner {
+    client: poise::serenity_prelude::Client,
+}
+
+pub struct Data {
+    server: Box<dyn ServerInfo>,
+    cached_reply: Mutex<Option<ServerResponse>>,
+}
+
+impl BotRunner {
+    pub async fn new(server: Box<dyn ServerInfo>) -> Self {
+        let token = server.app_token();
+        let framework = poise::Framework::builder()
+            .options(poise::FrameworkOptions {
+                commands: vec![players(), join()],
+                event_handler: |ctx, event, framework, data| {
+                    Box::pin(event_handler(ctx, event, framework, data))
+                },
+                ..Default::default()
+            })
+            .setup(|ctx, _ready, framework| {
+                Box::pin(async move {
+                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
+                    Ok(Data {
+                        server,
+                        cached_reply: Mutex::new(None),
+                    })
+                })
+            })
+            .build();
+
+        let client = ClientBuilder::new(token, GatewayIntents::non_privileged())
+            .framework(framework)
+            .activity(ActivityData::custom("Waiting on first heartbeat"))
+            .await
+            .unwrap();
+        BotRunner { client }
+    }
+
+    pub async fn run(&mut self) -> Result<(), serenity::Error> {
+        self.client.start().await
+    }
+}
+
+pub async fn event_handler(
+    ctx: &serenity::Context,
+    event: &serenity::FullEvent,
+    _framework: poise::FrameworkContext<'_, Data, serenity::Error>,
+    data: &Data,
+) -> Result<(), serenity::Error> {
+    match event {
+        serenity::FullEvent::Ready {
+            data_about_bot: _bot_data,
+        } => loop {
+            println!("Checking status: {}", data.server.api_address());
+            let http_response = request(data.server.api_address()).await.unwrap();
+            let results = data.server.parse(http_response.text().await.unwrap());
+            match &results {
+                ServerResponse::Offline => {
+                    ctx.set_presence(
+                        Some(ActivityData::custom("Server offline!")),
+                        serenity::OnlineStatus::DoNotDisturb,
+                    );
+                }
+                ServerResponse::Online(online_info) => {
+                    ctx.set_presence(
+                        Some(ActivityData::custom(format!(
+                            "{}/{} online, v{}",
+                            online_info.players_online,
+                            online_info.player_limit,
+                            online_info.version
+                        ))),
+                        if online_info.players_online > 0 {
+                            serenity::OnlineStatus::Online
+                        } else {
+                            serenity::OnlineStatus::Idle
+                        },
+                    );
+                }
+            }
+            //println!("{:#?}", &results);
+            *data.cached_reply.lock().await = Some(results);
+            tokio::time::sleep(std::time::Duration::from_secs(30)).await;
+        },
+        _ => Ok(()),
+    }
+}
+
+#[poise::command(slash_command)]
+pub async fn players(
+    ctx: poise::Context<'_, Data, serenity::Error>,
+) -> Result<(), serenity::Error> {
+    if let Some(reply) = &*ctx.data().cached_reply.lock().await {
+        match reply {
+            ServerResponse::Offline => ctx.say("Server is offline!").await?,
+            ServerResponse::Online(on) => {
+                if let Some(list) = &on.players {
+                    ctx.say(format!(
+                        "{} out of {} players are online.\nPlayers online: {}",
+                        on.players_online,
+                        on.player_limit,
+                        list.join(", ")
+                    ))
+                    .await?
+                } else {
+                    ctx.say(format!(
+                        "{} out of {} players are online.",
+                        on.players_online, on.player_limit
+                    ))
+                    .await?
+                }
+            }
+        };
+    } else {
+        ctx.say("No status response yet. Please wait 30 seconds.")
+            .await?;
+    }
+    Ok(())
+}
+
+#[poise::command(slash_command)]
+pub async fn join(
+    ctx: poise::Context<'_, Data, serenity::Error>,
+) -> Result<(), serenity::Error> {
+    ctx.say(format!("To join, type `{}` in the server URL box or search bar.", ctx.data().server.addressable_name())).await?;
+    Ok(())
+}

src/config_parser.rs

@@ -0,0 +1,37 @@
+use crate::{handlers, types::ServerInfo};
+use serde::Deserialize;
+use std::{fs::File, path::Path};
+use url::Url;
+
+#[derive(Deserialize)]
+pub struct ConfigEntry {
+    handler_type: String,
+    address: Url,
+    token: String,
+}
+
+#[derive(Deserialize)]
+pub struct Config {
+    version: String,
+    entries: Vec<ConfigEntry>,
+}
+
+pub fn parse_configs(path: &Path) -> Result<Config, anyhow::Error> {
+    let file_handle = File::open(path)?;
+    Ok(serde_json::from_reader::<File, Config>(file_handle)?)
+}
+
+pub fn build_handlers(conf: Config) -> Vec<Box<dyn ServerInfo>> {
+    assert_eq!(conf.version, "0.1.0");
+    let mut results: Vec<Box<dyn ServerInfo>> = vec![];
+    for item in conf.entries {
+        match item.handler_type.as_str() {
+            "minecraft" => results.push(Box::new(handlers::minecraft::Server::new(
+                item.token,
+                item.address,
+            ))),
+            _ => {}
+        }
+    }
+    results
+}

src/funcs.rs

@@ -1,30 +0,0 @@
-use poise::serenity_prelude::{ActivityData, OnlineStatus};
-
-use crate::types::ServerResponse;
-
-pub fn set_presence(ctx: &poise::serenity_prelude::Context, status: ServerResponse) {
-    ctx.set_presence(
-        Some(ActivityData::custom(match status.online() {
-            true => {
-                format!(
-                    "{}/{} players online {}",
-                    status.players().unwrap(),
-                    status.max().unwrap(),
-                    if let Some(version) = status.version() {
-                        format!("v{}", version)
-                    } else {
-                        "".into()
-                    }
-                )
-            }
-            false => "Server offline!".to_string(),
-        })),
-        match status.online() {
-            true => match status.is_full() {
-                true => OnlineStatus::Idle,
-                false => OnlineStatus::Online,
-            },
-            false => OnlineStatus::DoNotDisturb,
-        },
-    );
-}

src/handlers/minecraft.rs

@@ -0,0 +1,104 @@
+use serde::Deserialize;
+use serde_json;
+use url::Url;
+
+use crate::types::{ServerInfo, ServerOnlineResponse, ServerResponse};
+
+#[derive(Deserialize, Debug)]
+struct ApiResponse {
+    online: bool,
+    version: Option<String>,
+    players: Option<ApiResponsePlayers>,
+    motd: Option<Motd>,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+struct ApiResponsePlayers {
+    online: u64,
+    max: u64,
+    list: Option<Vec<ApiResponsePlayerEntry>>,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+struct ApiResponsePlayerEntry {
+    name: String,
+    #[allow(dead_code)]
+    uuid: String,
+}
+
+#[derive(Deserialize, Debug)]
+#[allow(dead_code)]
+struct Motd {
+    raw: Vec<String>,
+    clean: Vec<String>,
+    html: Vec<String>,
+}
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct OnlineResponse {
+    searchable_name: String,
+    reported_name: String,
+    clean_name: String,
+    players_online: u64,
+    player_limit: u64,
+    version: String,
+    players: Vec<String>,
+}
+
+pub struct Server {
+    #[allow(dead_code)]
+    token: String,
+    addr: Url,
+}
+
+impl ServerInfo for Server {
+    fn new(token: String, addr: Url) -> Self {
+        Server { token, addr }
+    }
+
+    fn addressable_name(&self) -> String {
+        self.addr.clone().into()
+    }
+
+    fn app_token(&self) -> String {
+        self.token.clone()
+    }
+
+    fn api_address(&self) -> Url {
+        let url_string = format!("https://api.mcsrvstat.us/3/{}", self.addr.host().unwrap());
+        Url::parse(&url_string).unwrap()
+    }
+
+    fn parse(&self, response: String) -> ServerResponse {
+        let parsed_data: ApiResponse = serde_json::from_str(&response).unwrap();
+        match parsed_data.online {
+            true => {
+                let players = parsed_data.players.unwrap();
+                let motd = parsed_data.motd.as_ref().unwrap();
+                self::ServerResponse::Online(ServerOnlineResponse {
+                    searchable_name: self.addr.host().unwrap().to_string(),
+                    readable_name: motd.clean.first().unwrap().into(),
+                    reported_name: motd.clean.first().unwrap().into(),
+                    clean_name: motd.clean.first().unwrap().into(),
+                    players_online: players.online,
+                    player_limit: players.max,
+                    version: parsed_data.version.unwrap(),
+                    players: Some(
+                        players
+                            .list
+                            .unwrap_or_default()
+                            .iter()
+                            .map(|e| e.name.clone())
+                            .collect(),
+                    ),
+                })
+            }
+            false => ServerResponse::Offline,
+        }
+    }
+
+    fn supports_playerlist(&self) -> bool {
+        true
+    }
+}

src/handlers/mod.rs

@@ -0,0 +1,2 @@
+pub mod minecraft;
+pub mod scpsl;

src/handlers/scpsl.rs

@@ -0,0 +1 @@
+

src/main.rs

@@ -1,33 +1,22 @@
-mod funcs;
+#![feature(impl_trait_in_bindings)]
-mod minecraft;
+mod bot_runner;
-mod scpsl;
+mod config_parser;
+mod handlers;
+mod request;
 mod types;
-use dotenvy::{self, dotenv};
-use minecraft::Minecraft;
-use tokio::join;
-use url::{self, Url};
 
-#[macro_use]
+use crate::bot_runner::BotRunner;
-extern crate log;
+use futures::{self, future::try_join_all};
+use std::path::Path;
 
 #[tokio::main]
 async fn main() {
-    dotenv().ok();
+    let config = config_parser::parse_configs(Path::new("config.json")).unwrap();
-    pretty_env_logger::init();
+    let handlers = config_parser::build_handlers(config);
-    let gamerzone = Minecraft::new(
+    let mut bots: Vec<bot_runner::BotRunner> = vec![];
-        Url::try_from("https://api.mcstatus.io/v2/status/java/bleat.shibedrill.site").unwrap(),
+    for item in handlers {
-        std::env::var("TOKEN_BOT_MC_BLEAT").unwrap(),
+        bots.push(BotRunner::new(item).await);
-        "DeersCord SMP".into(),
+    }
-    );
+    let futures: Vec<_> = bots.iter_mut().map(|b| b.run()).collect();
-    let mchprs = Minecraft::new(
+    let _ = try_join_all(futures).await;
-        Url::try_from("https://api.mcstatus.io/v2/status/java/mchprs.shibedrill.site").unwrap(),
-        std::env::var("TOKEN_BOT_MC_MCHPRS").unwrap(),
-        "Project MCRV".into(),
-    );
-    let dawn = Minecraft::new(
-        Url::try_from("https://api.mcstatus.io/v2/status/java/dawn.shibedrill.site").unwrap(),
-        std::env::var("TOKEN_BOT_MC_DAWN").unwrap(),
-        "Dawn Group".into(),
-    );
-    join!(mchprs.run(), gamerzone.run(), dawn.run());
 }

src/minecraft.rs

@@ -1,131 +0,0 @@
-use poise::serenity_prelude as serenity;
-use reqwest::{Client, Request};
-use serenity::*;
-use url::Url;
-
-use crate::{
-    funcs,
-    types::{self, ServerResponse},
-};
-
-#[derive(serde::Deserialize, Debug)]
-struct ServerSummary {
-    online: bool,
-    players: Option<Players>,
-    version: Version,
-}
-
-#[derive(serde::Deserialize, Debug)]
-struct Version {
-    name_raw: String,
-    name_clean: String,
-    name_html: String,
-    protocol: u32,
-}
-
-#[derive(serde::Deserialize, Debug)]
-struct Players {
-    online: i32,
-    max: i32,
-}
-
-pub struct Data {
-    controller: Minecraft,
-}
-
-#[derive(Clone)]
-pub struct Minecraft {
-    url: Url,
-    token: String,
-    name: String,
-}
-
-impl Minecraft {
-    pub fn new(url: Url, token: String, name: String) -> Self {
-        Self { url, token, name }
-    }
-
-    pub async fn get_status(&self) -> Result<ServerResponse, anyhow::Error> {
-        let http_client = Client::new();
-        trace!("Created HTTP client");
-        let request = Request::new(reqwest::Method::GET, self.url.clone());
-        trace!("Created HTTP request");
-        let response = http_client.execute(request).await?;
-        trace!("Ran request using client");
-        let data: ServerSummary = serde_json::from_str(&response.text().await?)?;
-
-        trace!("Response JSON for {}: {:#?}", self.name, data); // this
-
-        if let Some(players) = data.players {
-            Ok(ServerResponse::new(
-                data.online,
-                Some(players.online as u32),
-                Some(players.max as u32),
-                Some(data.version.name_raw),
-            ))
-        } else {
-            Ok(ServerResponse::new(data.online, None, None, None))
-        }
-    }
-    pub async fn run(&self) {
-        let controller = self.clone();
-        let framework = poise::Framework::builder()
-            .options(poise::FrameworkOptions {
-                event_handler: |ctx, event, framework, data| {
-                    Box::pin(event_handler(ctx, event, framework, data))
-                },
-                ..Default::default()
-            })
-            .setup(|ctx, _ready, framework| {
-                Box::pin(async move {
-                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
-                    Ok(Data { controller })
-                })
-            })
-            .build();
-        info!("Built framework successfully.");
-
-        let mut discord_client = ClientBuilder::new(
-            self.token.clone(),
-            serenity::GatewayIntents::non_privileged(),
-        )
-        .framework(framework)
-        .activity(ActivityData::custom("Waiting on initial status..."))
-        .await
-        .inspect_err(|e| error!("Failed to start client: {}", e))
-        .unwrap();
-        info!("Built client successfully.");
-
-        let _ = discord_client.start().await;
-    }
-}
-
-pub async fn event_handler(
-    ctx: &serenity::Context,
-    event: &serenity::FullEvent,
-    _framework: poise::FrameworkContext<'_, Data, Error>,
-    data: &Data,
-) -> Result<(), Error> {
-    match event {
-        serenity::FullEvent::Ready {
-            data_about_bot: _bot_data,
-        } => loop {
-            trace!("Running loop routine");
-            let status = data
-                .controller
-                .get_status()
-                .await
-                .inspect_err(|e| error!("{}: Failed to get status: {}", data.controller.name, e))
-                .unwrap();
-            info!(
-                "{}: Got status: {}",
-                data.controller.name,
-                status.to_string()
-            );
-
-            funcs::set_presence(ctx, status);
-            tokio::time::sleep(std::time::Duration::from_secs(30)).await;
-        },
-        _ => Ok(()),
-    }
-}

src/request.rs

@@ -0,0 +1,9 @@
+use reqwest::{header::HeaderValue, Response};
+use url::Url;
+
+pub async fn request(url: Url) -> Result<Response, reqwest::Error> {
+    let client = reqwest::Client::new();
+    let mut request = reqwest::Request::new(reqwest::Method::GET, url);
+    request.headers_mut().append("User-Agent", HeaderValue::from_str("Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36").unwrap());
+    client.execute(request).await
+}

src/scpsl.rs

@@ -1,115 +0,0 @@
-use crate::{funcs, types::ServerResponse};
-use poise::serenity_prelude as serenity;
-use reqwest::{Client, Request};
-use serenity::*;
-use url::Url;
-
-#[derive(serde::Deserialize, Debug)]
-#[allow(non_snake_case)]
-struct ServerSummary {
-    online: bool,
-    players: String,
-}
-
-pub struct Data {
-    controller: Scpsl,
-}
-
-#[derive(Clone)]
-pub struct Scpsl {
-    name: String,
-    url: Url,
-    token: String,
-}
-
-impl Scpsl {
-    pub fn new(url: Url, token: String, name: String) -> Self {
-        Self { url, token, name }
-    }
-    async fn get_status(&self) -> Result<ServerResponse, anyhow::Error> {
-        let http_client = Client::new();
-        trace!("Created HTTP client");
-        let request = Request::new(reqwest::Method::GET, self.url.clone());
-        trace!("Created HTTP request");
-        let response = http_client.execute(request).await?;
-        trace!("Ran request using client");
-        let data: ServerSummary = serde_json::from_str(&response.text().await?)?;
-
-        trace!("Response JSON for {}: {:#?}", self.name, data); // this is the only thing I added.
-
-        let playercount: Result<Vec<u32>, _> =
-            data.players.split('/').map(|x| x.parse::<u32>()).collect();
-
-        let playercount_unwrapped = playercount?;
-
-        Ok(ServerResponse::new(
-            data.online,
-            playercount_unwrapped.first().copied(),
-            playercount_unwrapped.get(1).copied(),
-            None,
-        ))
-    }
-
-    pub async fn run(&self) {
-        let controller = self.clone();
-        let framework = poise::Framework::builder()
-            .options(poise::FrameworkOptions {
-                initialize_owners: true,
-                event_handler: |ctx, event, framework, data| {
-                    Box::pin(event_handler(ctx, event, framework, data))
-                },
-                ..Default::default()
-            })
-            .setup(|ctx, _ready, framework| {
-                Box::pin(async move {
-                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
-                    Ok(Data { controller })
-                })
-            })
-            .build();
-        info!("Built framework successfully.");
-
-        let mut discord_client = ClientBuilder::new(
-            self.token.clone(),
-            serenity::GatewayIntents::non_privileged(),
-        )
-        .framework(framework)
-        .activity(ActivityData::custom("Waiting on initial status..."))
-        .await
-        .inspect_err(|e| error!("Failed to start client: {}", e))
-        .unwrap();
-        info!("Built client successfully.");
-
-        let _ = discord_client.start().await;
-    }
-}
-
-pub async fn event_handler(
-    ctx: &serenity::Context,
-    event: &serenity::FullEvent,
-    _framework: poise::FrameworkContext<'_, Data, Error>,
-    data: &Data,
-) -> Result<(), Error> {
-    match event {
-        serenity::FullEvent::Ready {
-            data_about_bot: _data,
-        } => loop {
-            trace!("Running loop routine");
-            let status = data
-                .controller
-                .get_status()
-                .await
-                .inspect_err(|e| error!("{}: Failed to get status: {}", data.controller.name, e))
-                .unwrap();
-            info!(
-                "{}: Got status: {}",
-                data.controller.name,
-                status.to_string()
-            );
-
-            funcs::set_presence(ctx, status);
-            tokio::time::sleep(std::time::Duration::from_secs(30)).await;
-        },
-        _ => Ok(()),
-    }
-}

src/types.rs

@@ -1,65 +1,40 @@
-use std::fmt::format;
+use url::Url;
 
-pub struct ServerResponse {
+#[derive(Debug)]
-    online: bool,
+pub enum ServerResponse {
-    players: Option<u32>,
+    Offline,
-    max: Option<u32>,
+    Online(ServerOnlineResponse),
-    version: Option<String>,
 }
 
-impl ServerResponse {
+#[derive(Debug)]
-    pub fn new(
+#[allow(dead_code)]
-        online: bool,
+pub struct ServerOnlineResponse {
-        players: Option<u32>,
+    pub players_online: u64,
-        max: Option<u32>,
+    pub player_limit: u64,
-        version: Option<String>,
+    pub version: String,
-    ) -> Self {
+    pub searchable_name: String,
-        ServerResponse {
+    pub readable_name: String,
-            online,
+    pub clean_name: String,
-            players,
+    pub reported_name: String,
-            max,
+    pub players: Option<Vec<String>>,
-            version,
+}
-        }
+
-    }
+#[allow(dead_code)]
-
+pub trait ServerInfo: Send + Sync {
-    pub fn online(&self) -> bool {
+    fn new(token: String, addr: Url) -> Self
-        self.online
+    where
-    }
+        Self: Sized;
-
+
-    pub fn players(&self) -> Option<u32> {
+    /// An addressable, unique identifier, used for its API.
-        self.players
+    /// If it is a Minecraft server, this can be a fully qualified domain name or URL.
-    }
+    /// If this is an SCP secret laboratory server, it can be a server ID.
-
+    fn addressable_name(&self) -> String;
-    pub fn max(&self) -> Option<u32> {
+    /// The address wrapped in the API URL.
-        self.max
+    fn api_address(&self) -> Url;
-    }
+    fn parse(&self, response: String) -> ServerResponse;
-
+
-    pub fn is_full(&self) -> bool {
+    /// The app token used to send status updates.
-        self.players >= self.max
+    fn app_token(&self) -> String;
-    }
+
-
+    fn supports_playerlist(&self) -> bool;
-    pub fn version(&self) -> &Option<String> {
-        &self.version
-    }
-
-    pub fn to_string(&self) -> String {
-        format!(
-            "{} {} {}",
-            if let Some(players) = self.players {
-                if let Some(max) = self.max {
-                    format!("{}/{}", players, max)
-                } else {
-                    players.to_string()
-                }
-            } else {
-                "N/A".into()
-            },
-            self.online,
-            if let Some(version) = &self.version {
-                version.to_string()
-            } else {
-                "N/A".into()
-            }
-        )
-    }
 }