Ensure uploads of same files will be cleaned from the database

@@ -22,7 +22,7 @@ use image::{ io::Reader as ImageReader
 
 
 pub fn launch() -> Sender<(Arc<Pool>, Image)> {
 pub fn launch() -> Sender<(Arc<Pool>, Image)> {
     let (tx_upload_worker, rx_upload_worker)
     let (tx_upload_worker, rx_upload_worker)
-        : (Sender<(Arc<Pool>, Image)>, Receiver<(Arc<Pool>, Image)>) = bounded(32);
+        : (Sender<(Arc<Pool>, Image)>, Receiver<(Arc<Pool>, Image)>) = bounded(100);
 
 
     actix_rt::spawn(async move {
     actix_rt::spawn(async move {
         let mut workers = FuturesUnordered::new();
         let mut workers = FuturesUnordered::new();
@@ -69,7 +69,8 @@ async fn store_original(context :&mut ImageContext) -> Result<(), Error> {
             Ok(())
             Ok(())
         },
         },
         Err(e) => Err(e)?,
         Err(e) => Err(e)?,
-        Ok(_) => Ok(()),
+        Ok(_) => Err(Error::new( "File already exists"
+                               , StatusCode::CONFLICT )),
     }
     }
 }
 }
 
 
@@ -101,48 +102,64 @@ async fn save_resized( original :&DynamicImage
 
 
     let original = original.to_owned();
     let original = original.to_owned();
 
 
-    spawn_blocking(move || -> Result<(), Error> {
-        let mut scaled = original.resize(width, height, Lanczos3);
-        overlay(&mut scaled, CONFIG.copyright_image(), 0_u32, 0_u32);
-
-        if let Size::Thumbnail = size {
-            scaled.save_with_format(&path, Jpeg)?;
-        } else {
-            let stegonography = CONFIG.copyright_steganography().as_bytes();
-            let encoder = Encoder::new(stegonography, scaled);
-            let scaled = encoder.encode_alpha();
-            scaled.save_with_format(&path, Jpeg)?;
-        }
+    match metadata(&path).await {
+        Err(e) if e.kind() == ErrorKind::NotFound =>
+            spawn_blocking(move || -> Result<(), Error> {
+                let mut scaled = original.resize(width, height, Lanczos3);
+                overlay(&mut scaled, CONFIG.copyright_image(), 0_u32, 0_u32);
+
+                if let Size::Thumbnail = size {
+                    scaled.save_with_format(&path, Jpeg)?;
+                } else {
+                    let stegonography = CONFIG.copyright_steganography().as_bytes();
+                    let encoder = Encoder::new(stegonography, scaled);
+                    let scaled = encoder.encode_alpha();
+                    scaled.save_with_format(&path, Jpeg)?;
+                }
 
 
-        let exiv = Metadata::new_from_path(&path)?;
-        exiv.set_tag_string("Exif.Image.Copyright", CONFIG.copyright_exiv())?;
-        exiv.save_to_file(&path)?;
+                let exiv = Metadata::new_from_path(&path)?;
+                exiv.set_tag_string("Exif.Image.Copyright", CONFIG.copyright_exiv())?;
+                exiv.save_to_file(&path)?;
 
 
-        Ok(())
-    }).await
+                Ok(())
+            }).await,
+        Err(e) => Err(e)?,
+        Ok(_) => Err(Error::new( "File already exists"
+                               , StatusCode::CONFLICT )),
+    }
 }
 }
 
 
 async fn worker(pool :Arc<Pool>, image :Image) -> Result<(), Error> {
 async fn worker(pool :Arc<Pool>, image :Image) -> Result<(), Error> {
     let mut context = image.context();
     let mut context = image.context();
+    let base_path = context.base_path().await
+                  . ok_or(Error::new( "Missing base_path"
+                                    , StatusCode::INTERNAL_SERVER_ERROR ))?;
 
 
     DirBuilder::new() . recursive(true)
     DirBuilder::new() . recursive(true)
-                      . create(context.base_path().await.unwrap())
-                      . await
-                      . unwrap();
+                      . create(base_path)
+                      . await?;
+
+    store_original(&mut context).await.unwrap_or(());
 
 
-    store_original(&mut context).await.unwrap();
+    if let Ok(original) = load_original(&mut context).await {
+        let (dim_x, dim_y) = original.dimensions();
 
 
-    let original = load_original(&mut context).await.unwrap();
-    let (dim_x, dim_y) = original.dimensions();
+        context.image.dim_x = Some(dim_x as i32);
+        context.image.dim_y = Some(dim_y as i32);
 
 
-    context.image.dim_x = Some(dim_x as i32);
-    context.image.dim_y = Some(dim_y as i32);
+        macro_rules! save_resized{
+            ($s:expr) => { save_resized(&original, &mut context, $s) }
+        }
 
 
-    save_resized(&original, &mut context, Size::Large).await?;
-    save_resized(&original, &mut context, Size::Medium).await?;
-    save_resized(&original, &mut context, Size::Small).await?;
-    save_resized(&original, &mut context, Size::Thumbnail).await?;
+        save_resized!(Size::Large).await.unwrap_or(());
+        save_resized!(Size::Medium).await.unwrap_or(());
+        save_resized!(Size::Small).await.unwrap_or(());
+        save_resized!(Size::Thumbnail).await.unwrap_or(());
+    }
 
 
+    // TODO Think about two simpler functions than finanlize...
+    // One to update one do remove the new entry depending if the
+    // entry exists already...
     web::block(move || finalize(pool, context.image)).await?;
     web::block(move || finalize(pool, context.image)).await?;
 
 
     Ok(())
     Ok(())