6 files changed, 85 insertions, 88 deletions

diff --git a/gitolfs3-server/Cargo.toml b/gitolfs3-server/Cargo.toml
index efea78b..91e2c57 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.8"
+aws-sdk-s3 = "1.128"
+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.51", 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..b80c83a 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;
 
@@ -168,25 +168,15 @@ fn default_transfers() -> Vec<TransferAdapter> {
     vec![TransferAdapter::Basic]
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Copy)]
+#[derive(Default, Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Copy)]
 pub enum HashAlgo {
+    #[default]
     #[serde(rename = "sha256")]
     Sha256,
     #[serde(other)]
     Unknown,
 }
 
-impl Default for HashAlgo {
-    fn default() -> Self {
-        Self::Sha256
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct BatchRef {
-    name: String,
-}
-
 #[derive(Debug, Serialize, Clone)]
 pub struct BatchResponse {
     pub transfer: TransferAdapter,
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..1f47c9e 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,
 };
@@ -42,7 +42,7 @@ enum ObjectStatus {
 impl AppState {
     async fn check_object(&self, repo: &str, obj: &BatchRequestObject) -> Result<ObjectStatus, ()> {
         let (oid0, oid1) = (HexByte(obj.oid[0]), HexByte(obj.oid[1]));
-        let full_path = format!("{repo}/lfs/objects/{}/{}/{}", oid0, oid1, obj.oid);
+        let full_path = format!("{repo}/lfs/objects/{oid0}/{oid1}/{}", obj.oid);
 
         let result = match self
             .s3_client
@@ -57,6 +57,14 @@ impl AppState {
             Err(SdkError::ServiceError(e)) if e.err().is_not_found() => {
                 return Ok(ObjectStatus::DoesNotExist);
             }
+            Err(SdkError::ServiceError(e)) => {
+                println!(
+                    "Failed to HeadObject (repo {repo}, OID {}): {}",
+                    e.err(),
+                    obj.oid
+                );
+                return Err(());
+            }
             Err(e) => {
                 println!("Failed to HeadObject (repo {repo}, OID {}): {e}", obj.oid);
                 return Err(());
@@ -80,7 +88,7 @@ async fn handle_download_object(
     trusted: bool,
 ) -> BatchResponseObject {
     let (oid0, oid1) = (HexByte(obj.oid[0]), HexByte(obj.oid[1]));
-    let full_path = format!("{repo}/lfs/objects/{}/{}/{}", oid0, oid1, obj.oid);
+    let full_path = format!("{repo}/lfs/objects/{oid0}/{oid1}/{}", obj.oid);
 
     let content_length = match state.check_object(repo, obj).await {
         Ok(ObjectStatus::ExistsOk { content_length }) => content_length,
@@ -144,31 +152,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(),
+                );
             }
         }
     }
@@ -259,7 +267,7 @@ pub async fn handle_obj_download(
         return e.into_response();
     }
 
-    let full_path = format!("{repo}/lfs/objects/{}/{}/{}", oid0, oid1, oid);
+    let full_path = format!("{repo}/lfs/objects/{oid0}/{oid1}/{oid}");
     let result = match state
         .s3_client
         .get_object()
@@ -270,6 +278,14 @@ pub async fn handle_obj_download(
         .await
     {
         Ok(result) => result,
+        Err(SdkError::ServiceError(e)) => {
+            println!("Failed to GetObject (repo {repo}, OID {oid}): {}", e.err());
+            return (
+                http::StatusCode::INTERNAL_SERVER_ERROR,
+                "Failed to query object information",
+            )
+                .into_response();
+        }
         Err(e) => {
             println!("Failed to GetObject (repo {repo}, OID {oid}): {e}");
             return (
@@ -308,7 +324,7 @@ async fn handle_upload_object(
     obj: &BatchRequestObject,
 ) -> Option<BatchResponseObject> {
     let (oid0, oid1) = (HexByte(obj.oid[0]), HexByte(obj.oid[1]));
-    let full_path = format!("{repo}/lfs/objects/{}/{}/{}", oid0, oid1, obj.oid);
+    let full_path = format!("{repo}/lfs/objects/{oid0}/{oid1}/{}", obj.oid);
 
     match state.check_object(repo, obj).await {
         Ok(ObjectStatus::ExistsOk { .. }) => {
@@ -433,12 +449,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);