feat: scaffold services/january

crates/services/january/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "revolt-january"
+version = "0.7.14"
+edition = "2021"
+
+[dependencies]
+# Utility
+mime = "0.3.17"
+lazy_static = "1.5.0"
+moka = { version = "0.12.8", features = ["future"] }
+
+# Serialisation
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.68"
+
+# Async runtime
+tokio = { version = "1.0", features = ["full"] }
+
+# Web requests
+reqwest = { version = "0.12", features = ["json"] }
+
+# Logging
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+# Core crates
+revolt-config = { version = "0.7.16", path = "../../core/config" }
+revolt-models = { version = "0.7.16", path = "../../core/models" }
+revolt-result = { version = "0.7.16", path = "../../core/result", features = [
+    "utoipa",
+    "axum",
+] }
+
+# Axum / web server
+axum = { version = "0.7.5" }
+axum-extra = { version = "0.9", features = ["typed-header"] }
+
+# OpenAPI & documentation generation
+utoipa-scalar = { version = "0.1.0", features = ["axum"] }
+utoipa = { version = "4.2.3", features = ["axum_extras", "ulid"] }

crates/services/january/src/api.rs

@@ -0,0 +1,85 @@
+use axum::{body::Bytes, extract::Query, routing::get, Json, Router};
+use revolt_models::v0::Embed;
+use revolt_result::Result;
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use axum_extra::{
+    headers::{authorization::Bearer, Authorization},
+    TypedHeader,
+};
+
+use crate::requests::Request;
+
+pub async fn router() -> Router {
+    Router::new()
+        .route("/", get(root))
+        .route("/proxy", get(proxy))
+        .route("/embed", get(embed))
+}
+
+/// Successful root response
+#[derive(Serialize, Debug, ToSchema)]
+pub struct RootResponse {
+    january: &'static str,
+    version: &'static str,
+}
+
+/// Capture crate version from Cargo
+static CRATE_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Root response from service
+#[utoipa::path(
+    get,
+    path = "/",
+    responses(
+        (status = 200, description = "Echo response", body = RootResponse)
+    )
+)]
+async fn root() -> Json<RootResponse> {
+    Json(RootResponse {
+        january: "Hello, I am a media proxy server!",
+        version: CRATE_VERSION,
+    })
+}
+
+#[derive(Deserialize)]
+struct UrlQuery {
+    url: String,
+}
+
+/// Proxy a given URL and load media
+#[utoipa::path(
+    get,
+    path = "/proxy",
+    responses(
+        (status = 200, description = "Requested media file", body = Vec<u8>)
+    ),
+    params(
+        ("url" = String, Query, description = "URL to fetch")
+    ),
+)]
+async fn proxy(Query(UrlQuery { url }): Query<UrlQuery>) -> Result<Bytes> {
+    Request::proxy_file(&url).await
+}
+
+/// Generate embed for a given URL
+#[utoipa::path(
+    get,
+    path = "/embed",
+    responses(
+        (status = 200, description = "Generated embed information", body = Embed)
+    ),
+    params(
+        ("url" = String, Query, description = "URL to fetch")
+    ),
+    security(
+        ("api_key" = [])
+    )
+)]
+async fn embed(
+    Query(UrlQuery { url }): Query<UrlQuery>,
+    TypedHeader(Authorization(_bearer)): TypedHeader<Authorization<Bearer>>,
+) -> Result<Json<Embed>> {
+    Request::generate_embed(&url).await.map(Json)
+}

crates/services/january/src/main.rs

@@ -0,0 +1,71 @@
+use std::net::{Ipv4Addr, SocketAddr};
+
+use axum::Router;
+
+use tokio::net::TcpListener;
+use utoipa::{
+    openapi::security::{Http, HttpAuthScheme, SecurityScheme},
+    Modify, OpenApi,
+};
+use utoipa_scalar::{Scalar, Servable as ScalarServable};
+
+mod api;
+pub mod requests;
+
+#[tokio::main]
+async fn main() -> Result<(), std::io::Error> {
+    // Configure logging and environment
+    revolt_config::configure!(api);
+
+    // Configure API schema
+    #[derive(OpenApi)]
+    #[openapi(
+        modifiers(&SecurityAddon),
+        paths(
+            api::root,
+            api::proxy,
+            api::embed
+        ),
+        components(
+            schemas(
+                api::RootResponse,
+                revolt_result::Error,
+                revolt_result::ErrorType,
+                revolt_models::v0::ImageSize,
+                revolt_models::v0::Image,
+                revolt_models::v0::Video,
+                revolt_models::v0::TwitchType,
+                revolt_models::v0::LightspeedType,
+                revolt_models::v0::BandcampType,
+                revolt_models::v0::Special,
+                revolt_models::v0::WebsiteMetadata,
+                revolt_models::v0::Text,
+                revolt_models::v0::Embed
+            )
+        )
+    )]
+    struct ApiDoc;
+
+    struct SecurityAddon;
+
+    impl Modify for SecurityAddon {
+        fn modify(&self, openapi: &mut utoipa::openapi::OpenApi) {
+            if let Some(components) = openapi.components.as_mut() {
+                components.add_security_scheme(
+                    "api_key",
+                    SecurityScheme::Http(Http::new(HttpAuthScheme::Bearer)),
+                )
+            }
+        }
+    }
+
+    // Configure Axum and router
+    let app = Router::new()
+        .merge(Scalar::with_url("/scalar", ApiDoc::openapi()))
+        .nest("/", api::router().await);
+
+    // Configure TCP listener and bind
+    let address = SocketAddr::from((Ipv4Addr::UNSPECIFIED, 3000));
+    let listener = TcpListener::bind(&address).await?;
+    axum::serve(listener, app.into_make_service()).await
+}

crates/services/january/src/requests.rs

@@ -0,0 +1,91 @@
+use std::time::Duration;
+
+use axum::body::Bytes;
+use lazy_static::lazy_static;
+use mime::Mime;
+use reqwest::{header::CONTENT_TYPE, redirect, Client, Response};
+use revolt_models::v0::Embed;
+use revolt_result::{create_error, Result};
+
+lazy_static! {
+    static ref CLIENT: Client = reqwest::Client::builder()
+        .user_agent("Mozilla/5.0 (compatible; January/2.0; +https://github.com/revoltchat/backend)")
+        .timeout(Duration::from_secs(10)) // TODO config
+        .connect_timeout(Duration::from_secs(5)) // TODO config
+        .redirect(redirect::Policy::custom(|attempt| {
+            if attempt.previous().len() > 5 { // TODO config
+                attempt.error("too many redirects")
+            } else if attempt.url().host_str() == Some("jan.revolt.chat") { // TODO config
+                attempt.stop()
+            } else {
+                attempt.follow()
+            }
+        }))
+        .build()
+        .expect("reqwest Client");
+
+    /// Cache for proxy results
+    static ref PROXY_CACHE: moka::future::Cache<String, Result<Bytes>> = moka::future::Cache::builder()
+        .max_capacity(10_000) // TODO config
+        .time_to_live(Duration::from_secs(60)) // TODO config
+        .build();
+
+    /// Cache for embed results
+    static ref EMBED_CACHE: moka::future::Cache<String, Result<Embed>> = moka::future::Cache::builder()
+        .max_capacity(1_000) // TODO config
+        .time_to_live(Duration::from_secs(60)) // TODO config
+        .build();
+}
+
+/// Information about a successful request
+pub struct Request {
+    response: Response,
+    mime: Mime,
+}
+
+impl Request {
+    /// Proxy a given URL
+    pub async fn proxy_file(url: &str) -> Result<Bytes> {
+        if let Some(hit) = PROXY_CACHE.get(url).await {
+            hit
+        } else {
+            todo!()
+        }
+    }
+
+    /// Generate embed for a given URL
+    pub async fn generate_embed(url: &str) -> Result<Embed> {
+        if let Some(hit) = EMBED_CACHE.get(url).await {
+            hit
+        } else {
+            todo!()
+        }
+    }
+
+    /// Send a new request to a service
+    pub async fn new(url: &str) -> Result<Request> {
+        let response = CLIENT
+            .get(url)
+            .send()
+            .await
+            .map_err(|_| create_error!(ProxyError))?;
+
+        if !response.status().is_success() {
+            tracing::error!("{:?}", response);
+            return Err(create_error!(ProxyError));
+        }
+
+        let content_type = response
+            .headers()
+            .get(CONTENT_TYPE)
+            .ok_or(create_error!(ProxyError))?
+            .to_str()
+            .map_err(|_| create_error!(ProxyError))?;
+
+        let mime: mime::Mime = content_type
+            .parse()
+            .map_err(|_| create_error!(ProxyError))?;
+
+        Ok(Request { response, mime })
+    }
+}