+ log files

+ more control on auth providers
+ server info in motd
+ bans and parsing minecraft server blacklist
+ more error handling
+ panic hook to tracing

src/api/v1/avatars.rs

@@ -1,21 +1,19 @@
-use axum::{body::Bytes, extract::{Path, State}, http::StatusCode, response::{IntoResponse, Response}};
+use axum::{body::Bytes, extract::{Path, State}};
 use tokio::{fs, io::{self, BufWriter}};
+use tracing::warn;
 use uuid::Uuid;
 
-use crate::{api::figura::profile::send_event, auth::Token, AppState};
+use crate::{api::figura::profile::send_event, auth::Token, ApiResult, AppState};
 
 pub async fn upload_avatar(
     Path(uuid): Path<Uuid>,
     Token(token): Token,
     State(state): State<AppState>,
     body: Bytes,
-) -> Response {
+) -> ApiResult<&'static str> {
     let request_data = body;
 
-    match state.config.lock().await.clone().verify_token(&token) {
-        Ok(_) => {},
-        Err(err) => return err,
-    };
+    state.config.read().await.clone().verify_token(&token)?;
 
     tracing::info!(
         "trying to upload the avatar for {}",
@@ -27,18 +25,15 @@ pub async fn upload_avatar(
     io::copy(&mut request_data.as_ref(), &mut file).await.unwrap();
     send_event(&state.broadcasts, &uuid);
 
-    (StatusCode::OK, "ok".to_string()).into_response()
+    Ok("ok")
 }
 
 pub async fn delete_avatar(
     Path(uuid): Path<Uuid>,
     Token(token): Token,
     State(state): State<AppState>
-) -> Response {
-    match state.config.lock().await.clone().verify_token(&token) {
-        Ok(_) => {},
-        Err(err) => return err,
-    };
+) -> ApiResult<&'static str> {
+    state.config.read().await.clone().verify_token(&token)?;
 
     tracing::info!(
         "trying to delete the avatar for {}",
@@ -48,9 +43,12 @@ pub async fn delete_avatar(
     let avatar_file = format!("avatars/{}.moon", &uuid);
     match fs::remove_file(avatar_file).await {
         Ok(_) => {},
-        Err(_) => return (StatusCode::NOT_FOUND, "avatar doesn't exist".to_string()).into_response()
+        Err(_) => {
+            warn!("avatar doesn't exist");
+            return Err(crate::ApiError::NotFound)
+        }
     };
     send_event(&state.broadcasts, &uuid);
 
-    (StatusCode::OK, "ok".to_string()).into_response()
+    Ok("ok")
 }

src/api/v1/http2ws.rs

@@ -1,20 +1,16 @@
-use axum::{
-    extract::{Query, State},
-    http::StatusCode,
-    response::{IntoResponse, Response}
-};
-use tracing::debug;
+use axum::extract::{Query, State};
+use tracing::{debug, trace, warn};
 
-use crate::{auth::Token, AppState};
+use crate::{api::errors::{error_and_log, internal_and_log}, auth::Token, ApiResult, AppState};
 use super::types::UserUuid;
 
 pub(super) async fn verify(
     Token(token): Token,
     State(state): State<AppState>,
-) -> Response {
-    state.config.lock().await.clone()
-        .verify_token(&token)
-        .unwrap_or_else(|x| x)
+) -> ApiResult<&'static str> {
+    state.config.read().await.clone()
+        .verify_token(&token)?;
+    Ok("ok")
 }
 
 pub(super) async fn raw(
@@ -22,33 +18,23 @@ pub(super) async fn raw(
     Query(query): Query<UserUuid>,
     State(state): State<AppState>,
     body: String,
-) -> Response {
-    debug!(body = body);
-    match state.config.lock().await.clone().verify_token(&token) {
-        Ok(_) => {},
-        Err(e) => return e,
-    }
-    let payload = match hex::decode(body) {
-        Ok(v) => v,
-        Err(_) => return (StatusCode::NOT_ACCEPTABLE, "not raw data".to_string()).into_response(),
-    };
+) -> ApiResult<&'static str> {
+    trace!(body = body);
+    state.config.read().await.clone().verify_token(&token)?;
+    let payload = hex::decode(body).map_err(|err| { warn!("not raw data"); error_and_log(err, crate::ApiError::NotAcceptable) })?;
     debug!("{:?}", payload);
 
     match query.uuid {
         Some(uuid) => {
             // for only one
-            let tx = match state.session.get(&uuid) {
-                Some(d) => d,
-                None => return (StatusCode::NOT_FOUND, "unknown uuid".to_string()).into_response(),
-            };
-            match tx.value().send(payload).await {
-                Ok(_) => return (StatusCode::OK, "ok".to_string()).into_response(),
-                Err(_) => return (StatusCode::INTERNAL_SERVER_ERROR, "cant send".to_string()).into_response(),
-            };
+            let tx = state.session.get(&uuid).ok_or_else(|| { warn!("unknown uuid"); crate::ApiError::NotFound })?;
+            tx.value().send(payload).await.map_err(|err| internal_and_log(err))?;
+            Ok("ok")
         },
         None => {
             // for all
-            return (StatusCode::NOT_FOUND, "uuid doesnt defined".to_string()).into_response();
+            warn!("uuid doesnt defined");
+            Err(crate::ApiError::NotFound)
         },
     }
 }
@@ -58,33 +44,22 @@ pub(super) async fn sub_raw(
     Query(query): Query<UserUuid>,
     State(state): State<AppState>,
     body: String,
-) -> Response {
-    debug!(body = body);
-    match state.config.lock().await.clone().verify_token(&token) {
-        Ok(_) => {},
-        Err(e) => return e,
-    }
-    let payload = match hex::decode(body) {
-        Ok(v) => v,
-        Err(_) => return (StatusCode::NOT_ACCEPTABLE, "not raw data".to_string()).into_response(),
-    };
+) -> ApiResult<&'static str> {
+    trace!(body = body);
+    state.config.read().await.clone().verify_token(&token)?;
+    let payload = hex::decode(body).map_err(|err| { warn!("not raw data"); error_and_log(err, crate::ApiError::NotAcceptable) })?;
     debug!("{:?}", payload);
-
     
     match query.uuid {
         Some(uuid) => {
             // for only one
-            let tx = match state.broadcasts.get(&uuid) {
-                Some(d) => d,
-                None => return (StatusCode::NOT_FOUND, "unknown uuid".to_string()).into_response(),
-            };
-            match tx.value().send(payload) {
-                Ok(_) => return (StatusCode::OK, "ok".to_string()).into_response(),
-                Err(_) => return (StatusCode::INTERNAL_SERVER_ERROR, "cant send".to_string()).into_response(),
-            };
+            let tx = state.broadcasts.get(&uuid).ok_or_else(|| { warn!("unknown uuid"); crate::ApiError::NotFound })?;
+            tx.value().send(payload).map_err(|err| internal_and_log(err))?;
+            Ok("ok")
         },
         None => {
-            return (StatusCode::NOT_FOUND, "uuid doesnt defined".to_string()).into_response();
+            warn!("uuid doesnt defined");
+            Err(crate::ApiError::NotFound)
         },
     }
 }

src/api/v1/users.rs

@@ -1,25 +1,20 @@
 use axum::{
     extract::State,
-    http::StatusCode,
-    response::{IntoResponse, Response},
     Json
 };
 use tracing::debug;
 
-use crate::{auth::{Token, Userinfo}, AppState};
+use crate::{auth::{Token, Userinfo}, ApiResult, AppState};
 
 pub(super) async fn create_user(
     Token(token): Token,
     State(state): State<AppState>,
     Json(json): Json<Userinfo>
-) -> Response {
-    match state.config.lock().await.clone().verify_token(&token) {
-        Ok(_) => {},
-        Err(e) => return e,
-    }
+) -> ApiResult<&'static str> {
+    state.config.read().await.clone().verify_token(&token)?;
 
     debug!("Creating new user: {json:?}");
     
     state.user_manager.insert_user(json.uuid, json);
-    (StatusCode::OK, "ok".to_string()).into_response()
+    Ok("ok")
 }