fix: lint

Author: ssddOnTop

src/server.rs

@@ -21,7 +21,6 @@ fn strip_leading_slash(s: &str) -> &str {
     s.strip_prefix('/').unwrap_or(s)
 }
 
-
 type SharedStorage = Arc<dyn Storage>;
 
 #[derive(Clone)]
@@ -47,7 +46,7 @@ pub struct RegistryServer {
 impl RegistryServer {
     pub async fn new(config: RegistryConfig) -> Result<Self> {
         let storage = create_storage(&config.storage).await?;
-        
+
         let state = AppState { storage };
 
         let app = Router::new()
@@ -63,7 +62,7 @@ impl RegistryServer {
             .layer(
                 tower::ServiceBuilder::new()
                     .layer(axum::extract::DefaultBodyLimit::max(512 * 1024 * 1024))
-                    .layer(TraceLayer::new_for_http())
+                    .layer(TraceLayer::new_for_http()),
             )
             .with_state(state);
 
@@ -115,10 +114,7 @@ async fn check_blob(
     info!("Checking blob: {}/{}", name, digest);
 
     match state.storage.get_blob(&digest).await {
-        Ok(Some(blob)) => (
-            StatusCode::OK,
-            [("Content-Length", blob.len().to_string())],
-        ),
+        Ok(Some(blob)) => (StatusCode::OK, [("Content-Length", blob.len().to_string())]),
         _ => (StatusCode::NOT_FOUND, [("Content-Length", "0".to_string())]),
     }
 }
@@ -154,10 +150,7 @@ async fn start_upload(
 
     (
         StatusCode::ACCEPTED,
-        [(
-            "Location",
-            format!("/v2/{}/blobs/uploads/{}", name, uuid),
-        )],
+        [("Location", format!("/v2/{}/blobs/uploads/{}", name, uuid))],
     )
 }
 
@@ -237,7 +230,11 @@ async fn finish_upload(
             format!("sha256:{}", hex::encode(hasher.finalize()))
         });
 
-    if let Err(e) = state.storage.store_blob(digest_str.clone(), upload_data).await {
+    if let Err(e) = state
+        .storage
+        .store_blob(digest_str.clone(), upload_data)
+        .await
+    {
         warn!("Failed to store blob: {}", e);
         return (
             StatusCode::INTERNAL_SERVER_ERROR,
@@ -302,7 +299,10 @@ async fn put_manifest(
         warn!("Failed to store manifest by digest: {}", e);
     }
 
-    info!("Stored manifest with digest: {} (type: {})", digest, content_type);
+    info!(
+        "Stored manifest with digest: {} (type: {})",
+        digest, content_type
+    );
 
     (
         StatusCode::CREATED,

src/storage.rs

@@ -1,5 +1,5 @@
-use crate::error::{RegistryError, Result};
 use crate::config::StorageBackend;
+use crate::error::{RegistryError, Result};
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::path::PathBuf;
@@ -87,7 +87,7 @@ impl DiskStorage {
         fs::create_dir_all(path.join("manifests")).await?;
         fs::create_dir_all(path.join("blobs")).await?;
         fs::create_dir_all(path.join("uploads")).await?;
-        
+
         Ok(Self {
             base_path: path,
             _temp_dir: None,
@@ -97,11 +97,11 @@ impl DiskStorage {
     pub async fn temp() -> Result<Self> {
         let temp_dir = tempfile::tempdir()?;
         let path = temp_dir.path().to_path_buf();
-        
+
         fs::create_dir_all(path.join("manifests")).await?;
         fs::create_dir_all(path.join("blobs")).await?;
         fs::create_dir_all(path.join("uploads")).await?;
-        
+
         Ok(Self {
             base_path: path,
             _temp_dir: Some(temp_dir),
@@ -110,12 +110,16 @@ impl DiskStorage {
 
     fn manifest_path(&self, key: &str) -> PathBuf {
         let safe_key = key.replace(['/', ':'], "_");
-        self.base_path.join("manifests").join(format!("{}.json", safe_key))
+        self.base_path
+            .join("manifests")
+            .join(format!("{}.json", safe_key))
     }
 
     fn manifest_meta_path(&self, key: &str) -> PathBuf {
         let safe_key = key.replace(['/', ':'], "_");
-        self.base_path.join("manifests").join(format!("{}.meta", safe_key))
+        self.base_path
+            .join("manifests")
+            .join(format!("{}.meta", safe_key))
     }
 
     fn blob_path(&self, digest: &str) -> PathBuf {
@@ -133,25 +137,26 @@ impl Storage for DiskStorage {
     async fn store_manifest(&self, key: String, entry: ManifestEntry) -> Result<()> {
         let manifest_path = self.manifest_path(&key);
         let meta_path = self.manifest_meta_path(&key);
-        
+
         fs::write(&manifest_path, &entry.data).await?;
         fs::write(&meta_path, &entry.content_type).await?;
-        
+
         Ok(())
     }
 
     async fn get_manifest(&self, key: &str) -> Result<Option<ManifestEntry>> {
         let manifest_path = self.manifest_path(key);
         let meta_path = self.manifest_meta_path(key);
-        
+
         if !manifest_path.exists() {
             return Ok(None);
         }
-        
+
         let data = fs::read(&manifest_path).await?;
-        let content_type = fs::read_to_string(&meta_path).await
+        let content_type = fs::read_to_string(&meta_path)
+            .await
             .unwrap_or_else(|_| "application/vnd.docker.distribution.manifest.v2+json".to_string());
-        
+
         Ok(Some(ManifestEntry { data, content_type }))
     }
 
@@ -163,11 +168,11 @@ impl Storage for DiskStorage {
 
     async fn get_blob(&self, digest: &str) -> Result<Option<Vec<u8>>> {
         let blob_path = self.blob_path(digest);
-        
+
         if !blob_path.exists() {
             return Ok(None);
         }
-        
+
         let data = fs::read(&blob_path).await?;
         Ok(Some(data))
     }
@@ -180,28 +185,28 @@ impl Storage for DiskStorage {
 
     async fn append_upload(&self, uuid: &str, data: &[u8]) -> Result<()> {
         let upload_path = self.upload_path(uuid);
-        
+
         if !upload_path.exists() {
             return Err(RegistryError::UploadNotFound(uuid.to_string()));
         }
-        
+
         let mut existing = fs::read(&upload_path).await?;
         existing.extend_from_slice(data);
         fs::write(&upload_path, &existing).await?;
-        
+
         Ok(())
     }
 
     async fn finish_upload(&self, uuid: &str) -> Result<Option<Vec<u8>>> {
         let upload_path = self.upload_path(uuid);
-        
+
         if !upload_path.exists() {
             return Ok(None);
         }
-        
+
         let data = fs::read(&upload_path).await?;
         fs::remove_file(&upload_path).await?;
-        
+
         Ok(Some(data))
     }
 }

tests/integration_test.rs

@@ -1,4 +1,6 @@
-use bollard::query_parameters::{CreateImageOptions, ListImagesOptions, PushImageOptions, RemoveImageOptions, TagImageOptions};
+use bollard::query_parameters::{
+    CreateImageOptions, ListImagesOptions, PushImageOptions, RemoveImageOptions, TagImageOptions,
+};
 use bollard::Docker;
 use futures_util::stream::StreamExt;
 use registry_testkit::{RegistryConfig, RegistryServer};
@@ -139,8 +141,7 @@ async fn test_docker_push_pull() {
         .await
         .unwrap();
 
-    let mut push_stream =
-        docker.push_image(&registry_image, None::<PushImageOptions>, None);
+    let mut push_stream = docker.push_image(&registry_image, None::<PushImageOptions>, None);
 
     while let Some(result) = push_stream.next().await {
         let info = result.unwrap();