Reduce verbosity of logs

Signed-off-by: Denys Fedoryshchenko <denys.f@collabora.com>

Author: nuclearcat

src/azure.rs

@@ -171,7 +171,7 @@ fn save_headers_to_file(filename: String, headers: HeaderMap) {
 /// Get file from Azure blob storage
 async fn get_file_from_blob(filename: String) -> ReceivedFile {
     let azure_cfg = Arc::new(get_azure_credentials("azure"));
-    println!("get_file_from_blob {}", filename);
+    //println!("get_file_from_blob {}", filename);
     let storage_account = azure_cfg.account.as_str();
     let storage_key = azure_cfg.key.clone();
     let storage_container = azure_cfg.container.as_str();
@@ -192,7 +192,7 @@ async fn get_file_from_blob(filename: String) -> ReceivedFile {
 
     match blob_url_res {
         Ok(url) => {
-            println!("Blob URL: {}", url);
+            //println!("Blob URL: {}", url);
             blob_url = url.to_string();
         }
         Err(e) => {
@@ -208,11 +208,11 @@ async fn get_file_from_blob(filename: String) -> ReceivedFile {
     let cache_filename_headers = format!("cache/{}.headers", digest.to_hex_lowercase());
     // check if cache file exists
     if std::path::Path::new(&cache_filename).exists() {
-        println!("Cache file {} exists", cache_filename);
+        //println!("Cache file {} exists", cache_filename);
         // is cached file non-zero length?
         let metadata = std::fs::metadata(&cache_filename).unwrap();
         if metadata.len() > 0 {
-            println!("Cache file {} is non-zero length", cache_filename);
+            //println!("Cache file {} is non-zero length", cache_filename);
             received_file.cached_filename = cache_filename;
             received_file.headers = get_headers_from_file(cache_filename_headers);
             received_file.valid = true;
@@ -240,10 +240,12 @@ async fn get_file_from_blob(filename: String) -> ReceivedFile {
             }
         }
     }
+    /*
     println!(
         "Downloading blob to cache file {} from {}",
         cache_filename, blob_url
     );
+    */
     let client = Client::new();
     let response = client.get(blob_url).send().await;
     match response {

src/main.rs

@@ -135,10 +135,7 @@ async fn main() {
         .route("/v1/file", post(ax_post_file))
         .route("/upload", post(ax_post_file))
         .route("/*filepath", get(ax_get_file))
-        .layer(
-            ServiceBuilder::new()
-                .layer(DefaultBodyLimit::max(1024 * 1024 * 1024 * 4)),
-        );
+        .layer(ServiceBuilder::new().layer(DefaultBodyLimit::max(1024 * 1024 * 1024 * 4)));
 
     /*
             .layer(SecureClientIpSource::ConnectInfo.into_extension())
@@ -292,16 +289,18 @@ async fn ax_get_file(
 ) -> impl IntoResponse {
     let timestamp = std::time::SystemTime::now();
     let human_time = chrono::DateTime::<chrono::Utc>::from(timestamp);
-    // or none
     let user_agent = rxheaders.get("User-Agent");
     let user_agent_str = match user_agent {
         Some(user_agent) => user_agent.to_str().unwrap(),
         None => "",
     };
-    // remote_addr human_time method filepath
-    println!("{:?} {} {} {} {}", remote_addr, human_time, method, filepath, user_agent_str);
+
     let received_file = driver_get_file(filepath.clone());
     if !received_file.valid {
+        println!(
+            "{:?} 404 0 {} {} {} {}",
+            remote_addr, human_time, method, filepath, user_agent_str
+        );
         return (StatusCode::NOT_FOUND, format!("Not Found: {}", filepath)).into_response();
     }
     let cached_file = received_file.cached_filename;
@@ -325,7 +324,11 @@ async fn ax_get_file(
 
     /* Usually HEAD is used to check if the file exists and range is supported */
     if method == axum::http::Method::HEAD {
-        println!("HEAD request, returning headers only");
+        //println!("HEAD request, returning headers only");
+        println!(
+            "{:?} 200 0 {} {} {} {}",
+            remote_addr, human_time, method, filepath, user_agent_str
+        );
         return (headers, Body::empty()).into_response();
     }
     match tokio::fs::File::open(&cached_file).await {
@@ -370,14 +373,32 @@ async fn ax_get_file(
             let stream = ReaderStream::new(file);
             let axbody = Body::from_stream(stream);
 
-            println!("Headers: {:?}", headers);
+            //println!("Headers: {:?}", headers);
             if start != 0 {
+                let body_size = end - start;
+                println!(
+                    "{:?} 206 {} {} {} {} {}",
+                    remote_addr, body_size, human_time, method, filepath, user_agent_str
+                );
                 return (StatusCode::PARTIAL_CONTENT, headers, axbody).into_response();
             }
+            println!(
+                "{:?} 200 {} {} {} {} {}",
+                remote_addr,
+                metadata.len(),
+                human_time,
+                method,
+                filepath,
+                user_agent_str
+            );
             return (StatusCode::OK, headers, axbody).into_response();
         }
         Err(_) => {
             println!("Error opening file in ax_get_file");
+            println!(
+                "{:?} 404 0 {} {} {} {}",
+                remote_addr, human_time, method, filepath, user_agent_str
+            );
             return (StatusCode::NOT_FOUND, headers, Body::empty()).into_response();
         }
     };