[webscrobbler] initialize webscrobler webhook server

Cargo.lock

···
 ]
 
 [[package]]
+name = "webscrobbler"
+version = "0.1.0"
+dependencies = [
+ "actix-web",
+ "anyhow",
+ "chrono",
+ "dotenv",
+ "hex",
+ "jsonwebtoken",
+ "md5",
+ "owo-colors",
+ "quick-xml 0.37.4",
+ "redis",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "sqlx",
+ "tokio",
+]
+
+[[package]]
 name = "whoami"
 version = "1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"

crates/webscrobbler/.gitignore

···
+.env

crates/webscrobbler/Cargo.toml

···
+[package]
+name = "webscrobbler"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[[bin]]
+name = "webscrobbler"
+path = "src/main.rs"
+
+[dependencies]
+serde = { version = "1.0.217", features = ["derive"] }
+serde_json = "1.0.139"
+sqlx = { version = "0.8.3", features = [
+  "runtime-tokio",
+  "tls-rustls",
+  "postgres",
+  "chrono",
+  "derive",
+  "macros",
+] }
+tokio = { version = "1.43.0", features = ["full"] }
+owo-colors = "4.1.0"
+dotenv = "0.15.0"
+anyhow = "1.0.96"
+actix-web = "4.9.0"
+redis = "0.29.0"
+hex = "0.4.3"
+jsonwebtoken = "9.3.1"
+md5 = "0.7.0"
+reqwest = { version = "0.12.12", features = [
+  "rustls-tls",
+  "json",
+  "multipart",
+], default-features = false }
+quick-xml = { version = "0.37.4", features = ["serialize"] }
+chrono = { version = "= 0.4.39", features = ["serde"] }

crates/webscrobbler/src/cache.rs

···
+use anyhow::Error;
+use redis::Client;
+use std::env;
+
+#[derive(Clone)]
+pub struct Cache {
+    pub client: Client,
+}
+
+impl Cache {
+    pub fn new() -> Result<Self, Error> {
+        let client =
+            redis::Client::open(env::var("REDIS_URL").unwrap_or("redis://127.0.0.1".into()))?;
+        Ok(Cache { client })
+    }
+
+    pub fn get(&self, key: &str) -> Result<Option<String>, Error> {
+        let mut con = self.client.get_connection()?;
+        let result: Option<String> = redis::cmd("GET").arg(key).query(&mut con)?;
+        Ok(result)
+    }
+
+    pub fn set(&self, key: &str, value: &str) -> Result<(), Error> {
+        let mut con = self.client.get_connection()?;
+        redis::cmd("SET")
+            .arg(key)
+            .arg(value)
+            .query::<()>(&mut con)?;
+        Ok(())
+    }
+
+    pub fn setex(&self, key: &str, value: &str, seconds: usize) -> Result<(), Error> {
+        let mut con = self.client.get_connection()?;
+        redis::cmd("SETEX")
+            .arg(key)
+            .arg(seconds)
+            .arg(value)
+            .query::<()>(&mut con)?;
+        Ok(())
+    }
+
+    pub fn exists(&self, key: &str) -> Result<bool, Error> {
+        let mut con = self.client.get_connection()?;
+        let result: bool = redis::cmd("EXISTS").arg(key).query(&mut con)?;
+        Ok(result)
+    }
+}

crates/webscrobbler/src/handlers.rs

···
+use actix_web::{get, HttpResponse, Responder};
+
+use crate::BANNER;
+
+
+#[get("/")]
+pub async fn index() -> impl Responder {
+  HttpResponse::Ok().body(BANNER)
+}

crates/webscrobbler/src/main.rs

···
+use std::{env, sync::Arc};
+
+use actix_web::{web::Data, App, HttpServer};
+use anyhow::Error;
+use cache::Cache;
+use dotenv::dotenv;
+use owo_colors::OwoColorize;
+use sqlx::postgres::PgPoolOptions;
+
+pub mod cache;
+pub mod handlers;
+
+pub const BANNER: &str = r#"
+  _       __     __   _____                 __    __    __
+ | |     / /__  / /_ / ___/______________  / /_  / /_  / /__  _____
+ | | /| / / _ \/ __ \\__ \/ ___/ ___/ __ \/ __ \/ __ \/ / _ \/ ___/
+ | |/ |/ /  __/ /_/ /__/ / /__/ /  / /_/ / /_/ / /_/ / /  __/ /
+ |__/|__/\___/_.___/____/\___/_/   \____/_.___/_.___/_/\___/_/
+
+
+    This is the Rocksky WebScrobbler Webhook API compatible with webscrobbler extension.
+"#;
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    dotenv().ok();
+
+    println!("{}", BANNER.magenta());
+
+    let cache = Cache::new()?;
+
+
+
+    let pool = PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&env::var("XATA_POSTGRES_URL")?)
+        .await?;
+
+    let conn = Arc::new(pool);
+
+
+    let host = env::var("WEBSCROBBLER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = env::var("WEBSCROBBLER_PORT")
+        .unwrap_or_else(|_| "7883".to_string())
+        .parse::<u16>()
+        .unwrap_or(7883);
+
+    println!(
+        "Starting WebScrobbler WebHook @ {}",
+        format!("{}:{}", host, port).green()
+    );
+
+    HttpServer::new(move || {
+        App::new()
+            .app_data(Data::new(conn.clone()))
+            .app_data(Data::new(cache.clone()))
+            .service(handlers::index)
+    })
+    .bind((host, port))?
+    .run()
+    .await?;
+
+    Ok(())
+}