chore: fmt

Author: voxxal

crates/api/src/api/challenges.rs

@@ -200,11 +200,15 @@ pub async fn submit(
                         .await?
                         .public_id
                     );
-                    client.post(u).json(&WebhookData {
-                        content: msg,
-                        embeds: None,
-                        attachments: Vec::new(),
-                    }).send().await?;
+                    client
+                        .post(u)
+                        .json(&WebhookData {
+                            content: msg,
+                            embeds: None,
+                            attachments: Vec::new(),
+                        })
+                        .send()
+                        .await?;
                 }
             }
         }

crates/api/src/api/leaderboard.rs

@@ -1,5 +1,9 @@
 use crate::{extractors::Auth, Error, Result, State, DB};
-use axum::{extract::{State as StateE, Path}, routing::get, Json, Router};
+use axum::{
+    extract::{Path, State as StateE},
+    routing::get,
+    Json, Router,
+};
 use chrono::{NaiveDateTime, Utc};
 use serde::Serialize;
 
@@ -93,7 +97,11 @@ async fn calculate_score_history(
     Ok(history)
 }
 
-async fn leaderboard(db: &DB, event_start_time: NaiveDateTime, division: Option<String>) -> Result<Vec<LeaderboardEntry>> {  
+async fn leaderboard(
+    db: &DB,
+    event_start_time: NaiveDateTime,
+    division: Option<String>,
+) -> Result<Vec<LeaderboardEntry>> {
     let db_entries = sqlx::query_as!(
         DbLeaderboardEntry,
         r#"
@@ -163,19 +171,25 @@ async fn leaderboard(db: &DB, event_start_time: NaiveDateTime, division: Option<
     Ok(leaderboard_entries)
 }
 
-async fn get_lb(StateE(state): StateE<State>,
+async fn get_lb(
+    StateE(state): StateE<State>,
     division: Option<Path<String>>,
 ) -> Result<Json<Vec<LeaderboardEntry>>> {
     if Utc::now().naive_utc() < state.event.start_time {
         return Err(Error::EventNotStarted(state.event.start_time.clone()));
     }
 
     let division = division.map(|x| x.0);
-    if division != None && state.event.divisions.get(division.as_ref().unwrap()).is_none() {
+    if division != None
+        && state
+            .event
+            .divisions
+            .get(division.as_ref().unwrap())
+            .is_none()
+    {
         return Err(Error::NotFoundDivision);
     }
- 
-    
+
     return leaderboard(&state.db, state.event.start_time, division)
         .await
         .map(Json);
@@ -184,5 +198,5 @@ async fn get_lb(StateE(state): StateE<State>,
 pub fn router() -> Router<crate::State> {
     Router::new()
         .route("/", get(get_lb))
-        .route("/{division}", get(get_lb)) 
+        .route("/{division}", get(get_lb))
 }

crates/api/src/api/profile.rs

@@ -1,4 +1,4 @@
-use crate::{extractors::Auth, jwt::Claims, Result, State, DB, Error};
+use crate::{extractors::Auth, jwt::Claims, Error, Result, State, DB};
 use axum::{
     extract::{Path, State as StateE},
     routing::{get, post},
@@ -10,7 +10,6 @@ use validator::Validate;
 
 use super::auth::{Team, TeamInfo, VerificationRequest};
 
-
 async fn update(
     StateE(state): StateE<State>,
     Auth(Claims { team_id, .. }): Auth,
@@ -38,7 +37,13 @@ async fn update(
     }
 
     if current_team.division != payload.division {
-        if payload.division != None && state.event.divisions.get(payload.division.as_ref().unwrap()).is_none() {
+        if payload.division != None
+            && state
+                .event
+                .divisions
+                .get(payload.division.as_ref().unwrap())
+                .is_none()
+        {
             return Err(Error::NotFoundDivision);
         }
         sqlx::query!(
@@ -49,7 +54,6 @@ async fn update(
         )
         .execute(&state.db)
         .await?;
-
     }
 
     if current_team.email != payload.email {

crates/api/src/error.rs

@@ -63,7 +63,9 @@ impl IntoResponse for Error {
             Error::Validation(_) => (StatusCode::BAD_REQUEST, "validation_error"),
             Error::Deploy(_) => (StatusCode::BAD_REQUEST, "deploy_error"),
             Error::InvalidToken => (StatusCode::UNAUTHORIZED, "invalid_token"),
-            Error::NotFoundChallenge | Error::NotFoundTeam | Error::NotFoundDivision => (StatusCode::NOT_FOUND, "not_found"),
+            Error::NotFoundChallenge | Error::NotFoundTeam | Error::NotFoundDivision => {
+                (StatusCode::NOT_FOUND, "not_found")
+            }
             Error::EventNotStarted(start_time) => {
                 // Event not started special cased to return start time
                 return (

crates/api/src/event.rs

@@ -1,7 +1,7 @@
 use axum::{extract::State as StateE, routing::get, Json, Router};
 use chrono::NaiveDateTime;
 use serde::{Deserialize, Serialize};
-use std::{fs, collections::HashMap};
+use std::{collections::HashMap, fs};
 
 use crate::{Result, State};
 

crates/api/src/extractors.rs

@@ -4,7 +4,11 @@ use crate::{
     config::Config,
     jwt::{decode_jwt, Claims},
 };
-use axum::{extract::{FromRequestParts, OptionalFromRequestParts}, http::request::Parts, RequestPartsExt};
+use axum::{
+    extract::{FromRequestParts, OptionalFromRequestParts},
+    http::request::Parts,
+    RequestPartsExt,
+};
 use axum_extra::extract::CookieJar;
 
 #[derive(Debug, Clone)]
@@ -34,7 +38,10 @@ where
 {
     type Rejection = crate::Error;
 
-    async fn from_request_parts(parts: &mut Parts, cfg: &B) -> Result<Option<Self>, Self::Rejection> {
+    async fn from_request_parts(
+        parts: &mut Parts,
+        cfg: &B,
+    ) -> Result<Option<Self>, Self::Rejection> {
         match <Auth as FromRequestParts<B>>::from_request_parts(parts, cfg).await {
             Ok(a) => Ok(Some(a)),
             Err(e) => match e {

crates/deployer-server/src/main.rs

@@ -10,9 +10,8 @@ mod error;
 
 use config::State;
 use error::Result;
-use tokio_util::{sync::CancellationToken, task::TaskTracker};
 use log::error;
-
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
@@ -39,13 +38,12 @@ async fn main() -> eyre::Result<()> {
     })?;
 
     let state = State::new(config::StateInner {
-            config: cfg,
-            db: pool.clone(),
-            challenge_data: challs.into(),
-            tasks: tt.clone(),
+        config: cfg,
+        db: pool.clone(),
+        challenge_data: challs.into(),
+        tasks: tt.clone(),
     });
 
-
     let inherited_containers = sqlx::query_as!(
         api::ChallengeDeploymentRow,
         "SELECT * FROM challenge_deployments WHERE destroyed_at IS NULL AND expired_at IS NOT NULL"
@@ -67,7 +65,10 @@ async fn main() -> eyre::Result<()> {
                 deploy::destroy_challenge_task(state_clone, container).await;
             });
         } else {
-            error!("failed to start cleanup task for deployment {}", container_id);
+            error!(
+                "failed to start cleanup task for deployment {}",
+                container_id
+            );
         }
     }