6 files changed, 63 insertions, 72 deletions

diff --git a/gitolfs3-server/Cargo.toml b/gitolfs3-server/Cargo.toml
index efea78b..5908770 100644
--- a/gitolfs3-server/Cargo.toml
+++ b/gitolfs3-server/Cargo.toml
@@ -1,20 +1,20 @@
 [package]
 name = "gitolfs3-server"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 license = "MIT"
 
 [dependencies]
-aws-config = { version = "1.1.2" }
-aws-sdk-s3 = "1.12.0"
-axum = "0.7"
-base64 = "0.21"
+aws-config = "1.6"
+aws-sdk-s3 = "1.82"
+axum = "0.8"
+base64 = "0.22"
 chrono = { version = "0.4", features = ["serde"] }
 gitolfs3-common = { path = "../gitolfs3-common" }
 mime = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-tokio = { version = "1.35", features = ["full"] }
+tokio = { version = "1.44", features = ["full"] }
 tokio-util = "0.7"
-tower = "0.4"
+tower = "0.5"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
diff --git a/gitolfs3-server/src/api.rs b/gitolfs3-server/src/api.rs
index d71d188..87c1856 100644
--- a/gitolfs3-server/src/api.rs
+++ b/gitolfs3-server/src/api.rs
@@ -1,15 +1,14 @@
 use std::collections::HashMap;
 
 use axum::{
-    async_trait,
-    extract::{rejection, FromRequest, FromRequestParts, Request},
+    Extension, Json,
+    extract::{FromRequest, FromRequestParts, Request, rejection},
     http,
     response::{IntoResponse, Response},
-    Extension, Json,
 };
 use chrono::{DateTime, Utc};
 use gitolfs3_common::{Oid, Operation};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
 
 // ----------------------- Generic facilities ----------------------
 
@@ -20,7 +19,10 @@ pub struct GitLfsErrorData<'a> {
     pub message: &'a str,
 }
 
-pub const fn make_error_resp(code: http::StatusCode, message: &str) -> GitLfsErrorResponse {
+pub const fn make_error_resp<'a>(
+    code: http::StatusCode,
+    message: &'a str,
+) -> GitLfsErrorResponse<'a> {
     (code, GitLfsJson(Json(GitLfsErrorData { message })))
 }
 
@@ -76,7 +78,6 @@ fn has_git_lfs_json_content_type(req: &Request) -> bool {
     is_git_lfs_json_mimetype(content_type)
 }
 
-#[async_trait]
 impl<T, S> FromRequest<S> for GitLfsJson<T>
 where
     T: DeserializeOwned,
@@ -122,7 +123,6 @@ impl IntoResponse for RepositoryNameRejection {
     }
 }
 
-#[async_trait]
 impl<S: Send + Sync> FromRequestParts<S> for RepositoryName {
     type Rejection = RepositoryNameRejection;
 
diff --git a/gitolfs3-server/src/authz.rs b/gitolfs3-server/src/authz.rs
index 8a5f21f..c4cb6df 100644
--- a/gitolfs3-server/src/authz.rs
+++ b/gitolfs3-server/src/authz.rs
@@ -2,10 +2,10 @@ use std::collections::HashSet;
 
 use axum::http;
 use chrono::{DateTime, Utc};
-use gitolfs3_common::{generate_tag, Claims, Digest, Oid, Operation, SpecificClaims};
+use gitolfs3_common::{Claims, Digest, Oid, Operation, SpecificClaims, generate_tag};
 
 use crate::{
-    api::{make_error_resp, GitLfsErrorResponse, REPO_NOT_FOUND},
+    api::{GitLfsErrorResponse, REPO_NOT_FOUND, make_error_resp},
     config::AuthorizationConfig,
 };
 
diff --git a/gitolfs3-server/src/config.rs b/gitolfs3-server/src/config.rs
index c6a51a5..5167cca 100644
--- a/gitolfs3-server/src/config.rs
+++ b/gitolfs3-server/src/config.rs
@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 
-use gitolfs3_common::{load_key, Key};
+use gitolfs3_common::{Key, load_key};
 
 pub struct Config {
     pub listen_addr: (String, u16),
@@ -18,19 +18,11 @@ pub struct AuthorizationConfig {
 
 impl Config {
     pub fn load() -> Result<Self, String> {
-        let env = match Env::load() {
-            Ok(env) => env,
-            Err(e) => return Err(format!("failed to load configuration: {e}")),
-        };
-
-        let s3_client = match create_s3_client(&env) {
-            Ok(s3_client) => s3_client,
-            Err(e) => return Err(format!("failed to create S3 client: {e}")),
-        };
-        let key = match load_key(&env.key_path) {
-            Ok(key) => key,
-            Err(e) => return Err(format!("failed to load Gitolfs3 key: {e}")),
-        };
+        let env = Env::load().map_err(|e| format!("failed to load configuration: {e}"))?;
+        let s3_client =
+            create_s3_client(&env).map_err(|e| format!("failed to create S3 client: {e}"))?;
+        let key =
+            load_key(&env.key_path).map_err(|e| format!("failed to load Gitolfs3 key: {e}"))?;
 
         let trusted_forwarded_hosts: HashSet<String> = env
             .trusted_forwarded_hosts
diff --git a/gitolfs3-server/src/handler.rs b/gitolfs3-server/src/handler.rs
index 64d5492..c5d4a61 100644
--- a/gitolfs3-server/src/handler.rs
+++ b/gitolfs3-server/src/handler.rs
@@ -2,24 +2,24 @@ use std::{collections::HashMap, sync::Arc};
 
 use aws_sdk_s3::{error::SdkError, operation::head_object::HeadObjectOutput};
 use axum::{
+    Json,
     extract::{Path, State},
     http,
     response::{IntoResponse, Response},
-    Json,
 };
-use base64::{prelude::BASE64_STANDARD, Engine};
+use base64::{Engine, prelude::BASE64_STANDARD};
 use chrono::Utc;
-use gitolfs3_common::{generate_tag, Claims, HexByte, Oid, Operation, SpecificClaims};
-use serde::{de, Deserialize};
+use gitolfs3_common::{Claims, HexByte, Oid, Operation, SpecificClaims, generate_tag};
+use serde::{Deserialize, de};
 use tokio::sync::Mutex;
 
 use crate::{
     api::{
-        is_git_lfs_json_mimetype, make_error_resp, BatchRequest, BatchRequestObject, BatchResponse,
-        BatchResponseObject, BatchResponseObjectAction, BatchResponseObjectActions, GitLfsJson,
-        HashAlgo, RepositoryName, TransferAdapter, LFS_MIME, REPO_NOT_FOUND,
+        BatchRequest, BatchRequestObject, BatchResponse, BatchResponseObject,
+        BatchResponseObjectAction, BatchResponseObjectActions, GitLfsJson, HashAlgo, LFS_MIME,
+        REPO_NOT_FOUND, RepositoryName, TransferAdapter, is_git_lfs_json_mimetype, make_error_resp,
     },
-    authz::{authorize_batch, authorize_get, Trusted},
+    authz::{Trusted, authorize_batch, authorize_get},
     config::AuthorizationConfig,
     dlimit::DownloadLimiter,
 };
@@ -144,31 +144,31 @@ async fn handle_download_object(
         };
     }
 
-    if let Some(content_length) = content_length {
-        if content_length > 0 {
-            match state
-                .dl_limiter
-                .lock()
-                .await
-                .request(content_length as u64)
-                .await
-            {
-                Ok(true) => {}
-                Ok(false) => {
-                    return BatchResponseObject::error(
-                        obj,
-                        http::StatusCode::SERVICE_UNAVAILABLE,
-                        "Public LFS downloads temporarily unavailable".to_string(),
-                    );
-                }
-                Err(e) => {
-                    println!("Failed to request {content_length} bytes from download limiter: {e}");
-                    return BatchResponseObject::error(
-                        obj,
-                        http::StatusCode::INTERNAL_SERVER_ERROR,
-                        "Internal server error".to_string(),
-                    );
-                }
+    if let Some(content_length) = content_length
+        && content_length > 0
+    {
+        match state
+            .dl_limiter
+            .lock()
+            .await
+            .request(content_length as u64)
+            .await
+        {
+            Ok(true) => {}
+            Ok(false) => {
+                return BatchResponseObject::error(
+                    obj,
+                    http::StatusCode::SERVICE_UNAVAILABLE,
+                    "Public LFS downloads temporarily unavailable".to_string(),
+                );
+            }
+            Err(e) => {
+                println!("Failed to request {content_length} bytes from download limiter: {e}");
+                return BatchResponseObject::error(
+                    obj,
+                    http::StatusCode::INTERNAL_SERVER_ERROR,
+                    "Internal server error".to_string(),
+                );
             }
         }
     }
@@ -433,12 +433,11 @@ fn s3_encode_checksum(oid: Oid) -> String {
 }
 
 fn s3_validate_checksum(oid: Oid, obj: &HeadObjectOutput) -> bool {
-    if let Some(checksum) = obj.checksum_sha256() {
-        if let Ok(checksum) = BASE64_STANDARD.decode(checksum) {
-            if let Ok(checksum32b) = TryInto::<[u8; 32]>::try_into(checksum) {
-                return Oid::from(checksum32b) == oid;
-            }
-        }
+    if let Some(checksum) = obj.checksum_sha256()
+        && let Ok(checksum) = BASE64_STANDARD.decode(checksum)
+        && let Ok(checksum32b) = TryInto::<[u8; 32]>::try_into(checksum)
+    {
+        return Oid::from(checksum32b) == oid;
     }
     true
 }
diff --git a/gitolfs3-server/src/main.rs b/gitolfs3-server/src/main.rs
index 46e840a..c88de76 100644
--- a/gitolfs3-server/src/main.rs
+++ b/gitolfs3-server/src/main.rs
@@ -9,12 +9,12 @@ use config::Config;
 use dlimit::DownloadLimiter;
 
 use axum::{
+    Router, ServiceExt,
     extract::OriginalUri,
     http::{self, Uri},
     routing::{get, post},
-    Router, ServiceExt,
 };
-use handler::{handle_batch, handle_obj_download, AppState};
+use handler::{AppState, handle_batch, handle_obj_download};
 use std::{process::ExitCode, sync::Arc};
 use tokio::net::TcpListener;
 use tower::Layer;
@@ -41,7 +41,7 @@ async fn main() -> ExitCode {
     });
     let app = Router::new()
         .route("/batch", post(handle_batch))
-        .route("/:oid0/:oid1/:oid", get(handle_obj_download))
+        .route("/{oid0}/{oid1}/{oid}", get(handle_obj_download))
         .with_state(shared_state);
 
     let middleware = axum::middleware::map_request(rewrite_url);